using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Data.SqlClient;
using System.IO;
using System.Runtime.Serialization;
using System.Xml;
using System.Xml.Schema;
namespace SLS.Presentation.Data
{
	#region GTARDataSet
	[Serializable()]
	[DesignerCategoryAttribute("code")]
	[System.Diagnostics.DebuggerStepThrough()]
	[ToolboxItem(true)]
	public class GTARDataSet: DataSet
	{
		private GTARDataTable _tableGTAR;
		
		[DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Content)]
		public GTARDataTable GTAR
		{
			get
			{
				return this._tableGTAR;
			}
		}
		
		public GTARDataSet()
		{
			this.InitClass();
		}
		
		protected override XmlSchema GetSchemaSerializable() 
		{
			MemoryStream stream = new MemoryStream();
			this.WriteXmlSchema(new	XmlTextWriter(stream, null));
			stream.Position = 0;
			return XmlSchema.Read(new XmlTextReader(stream), null);
		}
		
		protected override void	ReadXmlSerializable(XmlReader reader) 
		{
			this.Reset();
			DataSet ds = new DataSet();
			ds.ReadXml(reader);
			if ((ds.Tables["GTAR"] != null))
			{
				this.Tables.Add(new GTARDataTable(ds.Tables["GTAR"]));
			}
			this.DataSetName = ds.DataSetName;
			this.Prefix = ds.Prefix;
			this.Namespace = ds.Namespace;
			this.Locale = ds.Locale;
			this.CaseSensitive = ds.CaseSensitive;
			this.EnforceConstraints = ds.EnforceConstraints;
			this.Merge(ds, false, System.Data.MissingSchemaAction.Add);
			this.InitVars();
		}
		
		protected GTARDataSet(SerializationInfo info, StreamingContext context)
		{
			string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
			if ((strSchema != null))
			{
				DataSet ds = new DataSet();
				ds.ReadXmlSchema(new XmlTextReader(new System.IO.StringReader(strSchema)));
				if ((ds.Tables["GTAR"] != null))
				{
					this.Tables.Add(new GTARDataTable(ds.Tables["GTAR"]));
				}
				this.DataSetName = ds.DataSetName;
				this.Prefix = ds.Prefix;
				this.Namespace = ds.Namespace;
				this.Locale = ds.Locale;
				this.CaseSensitive = ds.CaseSensitive;
				this.EnforceConstraints = ds.EnforceConstraints;
				this.Merge(ds, false, System.Data.MissingSchemaAction.Add);
				this.InitVars();
			}
			else
			{
				this.InitClass();
			}
			this.GetSerializationData(info, context);
		}
		
		private void InitClass()
		{
			this.DataSetName = "GTARDataSet";
			_tableGTAR = new GTARDataTable();
			this.Tables.Add(_tableGTAR);
			this.ExtendedProperties.Add("ObjectName", "GTAR");
			this.ExtendedProperties.Add("ObjectDescription", "GTAR");
			this.ExtendedProperties.Add("NameSpace", "");
		}
		
		public override DataSet Clone()
		{
			GTARDataSet cln = ((GTARDataSet)(base.Clone()));
			cln.InitVars();
			return cln;
		}
		
		internal void InitVars()
		{
			_tableGTAR = ((GTARDataTable)(this.Tables["GTAR"]));
			if (_tableGTAR != null)
			{
				_tableGTAR.InitVars();
			}
		}
		
		protected override bool ShouldSerializeTables()
		{
			return false;
		}
		
		protected override bool ShouldSerializeRelations()
		{
			return false;
		}
		
		private bool ShouldSerializeGTAR()
		{
			return false;
		}
		
		public delegate void GTARRowChangeEventHandler(object sender, GTARRowChangeEventArgs e);
		
		[Serializable()]
		public class GTARDataTable: DataTable, System.Collections.IEnumerable
		{
			private DataColumn _columnSM;
			private DataColumn _columnGTPRE;
			private DataColumn _columnGTKEY;
			private DataColumn _columnPOS;
			private DataColumn _columnPPKEY;
			private DataColumn _columnPPTKEY;
			private DataColumn _columnGAPKEY;
			private DataColumn _columnMVTKEY;
			private DataColumn _columnSREAL;
			private DataColumn _columnSGTPRE;
			private DataColumn _columnSGTKEY;
			private DataColumn _columnSMULTIKEY;
			private DataColumn _columnSFKEY;
			private DataColumn _columnSGDKEYG;
			private DataColumn _columnIQTY;
			private DataColumn _columnINUM;
			private DataColumn _columnQTY;
			private DataColumn _columnUM;
			private DataColumn _columnLDES;
			private DataColumn _columnSDES;
			private DataColumn _columnLPOS;
			private DataColumn _columnVCK1;
			private DataColumn _columnEXPR1;
			private DataColumn _columnSUBSTATUS;
			private DataColumn _columnSTATUS;
			private DataColumn _columnFUSER;
			private DataColumn _columnFDATE;
			private DataColumn _columnLUSER;
			private DataColumn _columnLDATE;
			private DataColumn _columnUID;
			
			internal GTARDataTable(): base("GTAR")
			{
				this.InitClass();
			}
			
			protected GTARDataTable(SerializationInfo info, StreamingContext context): base(info, context)
			{
				this.InitVars();
			}
			
			internal GTARDataTable(DataTable table): base(table.TableName)
			{
				if (table.CaseSensitive != table.DataSet.CaseSensitive)
				{
					this.CaseSensitive = table.CaseSensitive;
				}
				if (table.Locale.ToString() != table.DataSet.Locale.ToString())
				{
					this.Locale = table.Locale;
				}
				if (table.Namespace != table.DataSet.Namespace)
				{
					this.Namespace = table.Namespace;
				}
				this.Prefix = table.Prefix;
				this.MinimumCapacity = table.MinimumCapacity;
				this.DisplayExpression = table.DisplayExpression;
			}
			
			public int Count
			{
				get
				{
					return this.Rows.Count;
				}
			}
			
			public DataColumn SMColumn
			{
				get
				{
					return _columnSM;
				}
			}
			
			public DataColumn GTPREColumn
			{
				get
				{
					return _columnGTPRE;
				}
			}
			
			public DataColumn GTKEYColumn
			{
				get
				{
					return _columnGTKEY;
				}
			}
			
			public DataColumn POSColumn
			{
				get
				{
					return _columnPOS;
				}
			}
			
			public DataColumn PPKEYColumn
			{
				get
				{
					return _columnPPKEY;
				}
			}
			
			public DataColumn PPTKEYColumn
			{
				get
				{
					return _columnPPTKEY;
				}
			}
			
			public DataColumn GAPKEYColumn
			{
				get
				{
					return _columnGAPKEY;
				}
			}
			
			public DataColumn MVTKEYColumn
			{
				get
				{
					return _columnMVTKEY;
				}
			}
			
			public DataColumn SREALColumn
			{
				get
				{
					return _columnSREAL;
				}
			}
			
			public DataColumn SGTPREColumn
			{
				get
				{
					return _columnSGTPRE;
				}
			}
			
			public DataColumn SGTKEYColumn
			{
				get
				{
					return _columnSGTKEY;
				}
			}
			
			public DataColumn SMULTIKEYColumn
			{
				get
				{
					return _columnSMULTIKEY;
				}
			}
			
			public DataColumn SFKEYColumn
			{
				get
				{
					return _columnSFKEY;
				}
			}
			
			public DataColumn SGDKEYGColumn
			{
				get
				{
					return _columnSGDKEYG;
				}
			}
			
			public DataColumn IQTYColumn
			{
				get
				{
					return _columnIQTY;
				}
			}
			
			public DataColumn INUMColumn
			{
				get
				{
					return _columnINUM;
				}
			}
			
			public DataColumn QTYColumn
			{
				get
				{
					return _columnQTY;
				}
			}
			
			public DataColumn UMColumn
			{
				get
				{
					return _columnUM;
				}
			}
			
			public DataColumn LDESColumn
			{
				get
				{
					return _columnLDES;
				}
			}
			
			public DataColumn SDESColumn
			{
				get
				{
					return _columnSDES;
				}
			}
			
			public DataColumn LPOSColumn
			{
				get
				{
					return _columnLPOS;
				}
			}
			
			public DataColumn VCK1Column
			{
				get
				{
					return _columnVCK1;
				}
			}
			
			public DataColumn EXPR1Column
			{
				get
				{
					return _columnEXPR1;
				}
			}
			
			public DataColumn SUBSTATUSColumn
			{
				get
				{
					return _columnSUBSTATUS;
				}
			}
			
			public DataColumn STATUSColumn
			{
				get
				{
					return _columnSTATUS;
				}
			}
			
			public DataColumn FUSERColumn
			{
				get
				{
					return _columnFUSER;
				}
			}
			
			public DataColumn FDATEColumn
			{
				get
				{
					return _columnFDATE;
				}
			}
			
			public DataColumn LUSERColumn
			{
				get
				{
					return _columnLUSER;
				}
			}
			
			public DataColumn LDATEColumn
			{
				get
				{
					return _columnLDATE;
				}
			}
			
			public DataColumn UIDColumn
			{
				get
				{
					return _columnUID;
				}
			}
			
			public GTARRow this[int index]
			{
				get
				{
					return ((GTARRow)(this.Rows[index]));
				}
			}
			
			public event GTARRowChangeEventHandler GTARRowChanged;
			public event GTARRowChangeEventHandler GTARRowChanging;
			public event GTARRowChangeEventHandler GTARRowDeleted;
			public event GTARRowChangeEventHandler GTARRowDeleting;
			
			public void AddGTARRow(GTARRow row)
			{
				this.Rows.Add(row);
			}
			
			public GTARRow AddGTARRow(
					string sm,
					string gtpre,
					string gtkey,
					int pos,
					string ppkey,
					string pptkey,
					string gapkey,
					string mvtkey,
					string sreal,
					string sgtpre,
					string sgtkey,
					string smultikey,
					string sfkey,
					string sgdkeyg,
					string iqty,
					string inum,
					string qty,
					string um,
					string ldes,
					string sdes,
					int lpos,
					string vck1,
					string expr1,
					string substatus,
					string status,
					string fuser,
					DateTime fdate,
					string luser,
					DateTime ldate,
					string uid
				)
			{
				GTARRow rowGTARRow = ((GTARRow)(this.NewRow()));
				rowGTARRow["SM"] = sm;
				rowGTARRow["GTPRE"] = gtpre;
				rowGTARRow["GTKEY"] = gtkey;
				rowGTARRow["POS"] = pos;
				rowGTARRow["PPKEY"] = ppkey;
				rowGTARRow["PPTKEY"] = pptkey;
				rowGTARRow["GAPKEY"] = gapkey;
				rowGTARRow["MVTKEY"] = mvtkey;
				rowGTARRow["SREAL"] = sreal;
				rowGTARRow["SGTPRE"] = sgtpre;
				rowGTARRow["SGTKEY"] = sgtkey;
				rowGTARRow["SMULTIKEY"] = smultikey;
				rowGTARRow["SFKEY"] = sfkey;
				rowGTARRow["SGDKEYG"] = sgdkeyg;
				rowGTARRow["IQTY"] = iqty;
				rowGTARRow["INUM"] = inum;
				rowGTARRow["QTY"] = qty;
				rowGTARRow["UM"] = um;
				rowGTARRow["LDES"] = ldes;
				rowGTARRow["SDES"] = sdes;
				rowGTARRow["LPOS"] = lpos;
				rowGTARRow["VCK1"] = vck1;
				rowGTARRow["EXPR1"] = expr1;
				rowGTARRow["SUBSTATUS"] = substatus;
				rowGTARRow["STATUS"] = status;
				rowGTARRow["FUSER"] = fuser;
				rowGTARRow["FDATE"] = fdate;
				rowGTARRow["LUSER"] = luser;
				rowGTARRow["LDATE"] = ldate;
				rowGTARRow["UID"] = uid;
				this.Rows.Add(rowGTARRow);
				return rowGTARRow;
			}
			
			public IEnumerator GetEnumerator()
			{
				return this.Rows.GetEnumerator();
			}
			
			public override DataTable Clone()
			{
				GTARDataTable cln = ((GTARDataTable)(base.Clone()));
				cln.InitVars();
				return cln;
			}
			
			internal void InitVars()
			{
				_columnSM = this.Columns["SM"];
				_columnGTPRE = this.Columns["GTPRE"];
				_columnGTKEY = this.Columns["GTKEY"];
				_columnPOS = this.Columns["POS"];
				_columnPPKEY = this.Columns["PPKEY"];
				_columnPPTKEY = this.Columns["PPTKEY"];
				_columnGAPKEY = this.Columns["GAPKEY"];
				_columnMVTKEY = this.Columns["MVTKEY"];
				_columnSREAL = this.Columns["SREAL"];
				_columnSGTPRE = this.Columns["SGTPRE"];
				_columnSGTKEY = this.Columns["SGTKEY"];
				_columnSMULTIKEY = this.Columns["SMULTIKEY"];
				_columnSFKEY = this.Columns["SFKEY"];
				_columnSGDKEYG = this.Columns["SGDKEYG"];
				_columnIQTY = this.Columns["IQTY"];
				_columnINUM = this.Columns["INUM"];
				_columnQTY = this.Columns["QTY"];
				_columnUM = this.Columns["UM"];
				_columnLDES = this.Columns["LDES"];
				_columnSDES = this.Columns["SDES"];
				_columnLPOS = this.Columns["LPOS"];
				_columnVCK1 = this.Columns["VCK1"];
				_columnEXPR1 = this.Columns["EXPR1"];
				_columnSUBSTATUS = this.Columns["SUBSTATUS"];
				_columnSTATUS = this.Columns["STATUS"];
				_columnFUSER = this.Columns["FUSER"];
				_columnFDATE = this.Columns["FDATE"];
				_columnLUSER = this.Columns["LUSER"];
				_columnLDATE = this.Columns["LDATE"];
				_columnUID = this.Columns["UID"];
			}
			
			public void InitClass()
			{
				_columnSM = new DataColumn("SM", typeof(string), "", MappingType.Element);
				_columnSM.AllowDBNull = false;
				_columnSM.Caption = "Sm";
				_columnSM.MaxLength = 10;
				_columnSM.Unique = false;
				_columnSM.DefaultValue = Convert.DBNull;
				_columnSM.ExtendedProperties.Add("IsKey", "true");
				_columnSM.ExtendedProperties.Add("ReadOnly", "false");
				_columnSM.ExtendedProperties.Add("Description", "Sm");
				_columnSM.ExtendedProperties.Add("Length", "10");
				_columnSM.ExtendedProperties.Add("Decimals", "0");
				_columnSM.ExtendedProperties.Add("AllowDBNulls", "false");
				this.Columns.Add(_columnSM);
				
				_columnGTPRE = new DataColumn("GTPRE", typeof(string), "", MappingType.Element);
				_columnGTPRE.AllowDBNull = false;
				_columnGTPRE.Caption = "Gtpre";
				_columnGTPRE.MaxLength = 2;
				_columnGTPRE.Unique = false;
				_columnGTPRE.DefaultValue = Convert.DBNull;
				_columnGTPRE.ExtendedProperties.Add("IsKey", "true");
				_columnGTPRE.ExtendedProperties.Add("ReadOnly", "false");
				_columnGTPRE.ExtendedProperties.Add("Description", "Gtpre");
				_columnGTPRE.ExtendedProperties.Add("Length", "2");
				_columnGTPRE.ExtendedProperties.Add("Decimals", "0");
				_columnGTPRE.ExtendedProperties.Add("AllowDBNulls", "false");
				this.Columns.Add(_columnGTPRE);
				
				_columnGTKEY = new DataColumn("GTKEY", typeof(string), "", MappingType.Element);
				_columnGTKEY.AllowDBNull = false;
				_columnGTKEY.Caption = "Gtkey";
				_columnGTKEY.MaxLength = 10;
				_columnGTKEY.Unique = false;
				_columnGTKEY.DefaultValue = Convert.DBNull;
				_columnGTKEY.ExtendedProperties.Add("IsKey", "true");
				_columnGTKEY.ExtendedProperties.Add("ReadOnly", "false");
				_columnGTKEY.ExtendedProperties.Add("Description", "Gtkey");
				_columnGTKEY.ExtendedProperties.Add("Length", "10");
				_columnGTKEY.ExtendedProperties.Add("Decimals", "0");
				_columnGTKEY.ExtendedProperties.Add("AllowDBNulls", "false");
				this.Columns.Add(_columnGTKEY);
				
				_columnPOS = new DataColumn("POS", typeof(int), "", MappingType.Element);
				_columnPOS.AllowDBNull = false;
				_columnPOS.Caption = "Pos";
				_columnPOS.Unique = false;
				_columnPOS.DefaultValue = Convert.DBNull;
				_columnPOS.ExtendedProperties.Add("IsKey", "true");
				_columnPOS.ExtendedProperties.Add("ReadOnly", "false");
				_columnPOS.ExtendedProperties.Add("Description", "Pos");
				_columnPOS.ExtendedProperties.Add("Decimals", "0");
				_columnPOS.ExtendedProperties.Add("AllowDBNulls", "false");
				this.Columns.Add(_columnPOS);
				
				_columnPPKEY = new DataColumn("PPKEY", typeof(string), "", MappingType.Element);
				_columnPPKEY.AllowDBNull = true;
				_columnPPKEY.Caption = "Ppkey";
				_columnPPKEY.MaxLength = 50;
				_columnPPKEY.Unique = false;
				_columnPPKEY.DefaultValue = Convert.DBNull;
				_columnPPKEY.ExtendedProperties.Add("IsKey", "false");
				_columnPPKEY.ExtendedProperties.Add("ReadOnly", "false");
				_columnPPKEY.ExtendedProperties.Add("Description", "Ppkey");
				_columnPPKEY.ExtendedProperties.Add("Length", "50");
				_columnPPKEY.ExtendedProperties.Add("Decimals", "0");
				_columnPPKEY.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnPPKEY);
				
				_columnPPTKEY = new DataColumn("PPTKEY", typeof(string), "", MappingType.Element);
				_columnPPTKEY.AllowDBNull = true;
				_columnPPTKEY.Caption = "Pptkey";
				_columnPPTKEY.MaxLength = 50;
				_columnPPTKEY.Unique = false;
				_columnPPTKEY.DefaultValue = Convert.DBNull;
				_columnPPTKEY.ExtendedProperties.Add("IsKey", "false");
				_columnPPTKEY.ExtendedProperties.Add("ReadOnly", "false");
				_columnPPTKEY.ExtendedProperties.Add("Description", "Pptkey");
				_columnPPTKEY.ExtendedProperties.Add("Length", "50");
				_columnPPTKEY.ExtendedProperties.Add("Decimals", "0");
				_columnPPTKEY.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnPPTKEY);
				
				_columnGAPKEY = new DataColumn("GAPKEY", typeof(string), "", MappingType.Element);
				_columnGAPKEY.AllowDBNull = true;
				_columnGAPKEY.Caption = "Gapkey";
				_columnGAPKEY.MaxLength = 50;
				_columnGAPKEY.Unique = false;
				_columnGAPKEY.DefaultValue = Convert.DBNull;
				_columnGAPKEY.ExtendedProperties.Add("IsKey", "false");
				_columnGAPKEY.ExtendedProperties.Add("ReadOnly", "false");
				_columnGAPKEY.ExtendedProperties.Add("Description", "Gapkey");
				_columnGAPKEY.ExtendedProperties.Add("Length", "50");
				_columnGAPKEY.ExtendedProperties.Add("Decimals", "0");
				_columnGAPKEY.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnGAPKEY);
				
				_columnMVTKEY = new DataColumn("MVTKEY", typeof(string), "", MappingType.Element);
				_columnMVTKEY.AllowDBNull = true;
				_columnMVTKEY.Caption = "Mvtkey";
				_columnMVTKEY.MaxLength = 50;
				_columnMVTKEY.Unique = false;
				_columnMVTKEY.DefaultValue = Convert.DBNull;
				_columnMVTKEY.ExtendedProperties.Add("IsKey", "false");
				_columnMVTKEY.ExtendedProperties.Add("ReadOnly", "false");
				_columnMVTKEY.ExtendedProperties.Add("Description", "Mvtkey");
				_columnMVTKEY.ExtendedProperties.Add("Length", "50");
				_columnMVTKEY.ExtendedProperties.Add("Decimals", "0");
				_columnMVTKEY.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnMVTKEY);
				
				_columnSREAL = new DataColumn("SREAL", typeof(string), "", MappingType.Element);
				_columnSREAL.AllowDBNull = true;
				_columnSREAL.Caption = "Sreal";
				_columnSREAL.MaxLength = 100;
				_columnSREAL.Unique = false;
				_columnSREAL.DefaultValue = Convert.DBNull;
				_columnSREAL.ExtendedProperties.Add("IsKey", "false");
				_columnSREAL.ExtendedProperties.Add("ReadOnly", "false");
				_columnSREAL.ExtendedProperties.Add("Description", "Sreal");
				_columnSREAL.ExtendedProperties.Add("Length", "100");
				_columnSREAL.ExtendedProperties.Add("Decimals", "0");
				_columnSREAL.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnSREAL);
				
				_columnSGTPRE = new DataColumn("SGTPRE", typeof(string), "", MappingType.Element);
				_columnSGTPRE.AllowDBNull = true;
				_columnSGTPRE.Caption = "Sgtpre";
				_columnSGTPRE.MaxLength = 10;
				_columnSGTPRE.Unique = false;
				_columnSGTPRE.DefaultValue = Convert.DBNull;
				_columnSGTPRE.ExtendedProperties.Add("IsKey", "false");
				_columnSGTPRE.ExtendedProperties.Add("ReadOnly", "false");
				_columnSGTPRE.ExtendedProperties.Add("Description", "Sgtpre");
				_columnSGTPRE.ExtendedProperties.Add("Length", "10");
				_columnSGTPRE.ExtendedProperties.Add("Decimals", "0");
				_columnSGTPRE.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnSGTPRE);
				
				_columnSGTKEY = new DataColumn("SGTKEY", typeof(string), "", MappingType.Element);
				_columnSGTKEY.AllowDBNull = true;
				_columnSGTKEY.Caption = "Sgtkey";
				_columnSGTKEY.MaxLength = 2;
				_columnSGTKEY.Unique = false;
				_columnSGTKEY.DefaultValue = Convert.DBNull;
				_columnSGTKEY.ExtendedProperties.Add("IsKey", "false");
				_columnSGTKEY.ExtendedProperties.Add("ReadOnly", "false");
				_columnSGTKEY.ExtendedProperties.Add("Description", "Sgtkey");
				_columnSGTKEY.ExtendedProperties.Add("Length", "2");
				_columnSGTKEY.ExtendedProperties.Add("Decimals", "0");
				_columnSGTKEY.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnSGTKEY);
				
				_columnSMULTIKEY = new DataColumn("SMULTIKEY", typeof(string), "", MappingType.Element);
				_columnSMULTIKEY.AllowDBNull = true;
				_columnSMULTIKEY.Caption = "Smultikey";
				_columnSMULTIKEY.MaxLength = 10;
				_columnSMULTIKEY.Unique = false;
				_columnSMULTIKEY.DefaultValue = Convert.DBNull;
				_columnSMULTIKEY.ExtendedProperties.Add("IsKey", "false");
				_columnSMULTIKEY.ExtendedProperties.Add("ReadOnly", "false");
				_columnSMULTIKEY.ExtendedProperties.Add("Description", "Smultikey");
				_columnSMULTIKEY.ExtendedProperties.Add("Length", "10");
				_columnSMULTIKEY.ExtendedProperties.Add("Decimals", "0");
				_columnSMULTIKEY.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnSMULTIKEY);
				
				_columnSFKEY = new DataColumn("SFKEY", typeof(string), "", MappingType.Element);
				_columnSFKEY.AllowDBNull = true;
				_columnSFKEY.Caption = "Sfkey";
				_columnSFKEY.MaxLength = 100;
				_columnSFKEY.Unique = false;
				_columnSFKEY.DefaultValue = Convert.DBNull;
				_columnSFKEY.ExtendedProperties.Add("IsKey", "false");
				_columnSFKEY.ExtendedProperties.Add("ReadOnly", "false");
				_columnSFKEY.ExtendedProperties.Add("Description", "Sfkey");
				_columnSFKEY.ExtendedProperties.Add("Length", "100");
				_columnSFKEY.ExtendedProperties.Add("Decimals", "0");
				_columnSFKEY.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnSFKEY);
				
				_columnSGDKEYG = new DataColumn("SGDKEYG", typeof(string), "", MappingType.Element);
				_columnSGDKEYG.AllowDBNull = true;
				_columnSGDKEYG.Caption = "Sgdkeyg";
				_columnSGDKEYG.MaxLength = 10;
				_columnSGDKEYG.Unique = false;
				_columnSGDKEYG.DefaultValue = Convert.DBNull;
				_columnSGDKEYG.ExtendedProperties.Add("IsKey", "false");
				_columnSGDKEYG.ExtendedProperties.Add("ReadOnly", "false");
				_columnSGDKEYG.ExtendedProperties.Add("Description", "Sgdkeyg");
				_columnSGDKEYG.ExtendedProperties.Add("Length", "10");
				_columnSGDKEYG.ExtendedProperties.Add("Decimals", "0");
				_columnSGDKEYG.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnSGDKEYG);
				
				_columnIQTY = new DataColumn("IQTY", typeof(string), "", MappingType.Element);
				_columnIQTY.AllowDBNull = true;
				_columnIQTY.Caption = "Iqty";
				_columnIQTY.MaxLength = 20;
				_columnIQTY.Unique = false;
				_columnIQTY.DefaultValue = Convert.DBNull;
				_columnIQTY.ExtendedProperties.Add("IsKey", "false");
				_columnIQTY.ExtendedProperties.Add("ReadOnly", "false");
				_columnIQTY.ExtendedProperties.Add("Description", "Iqty");
				_columnIQTY.ExtendedProperties.Add("Length", "20");
				_columnIQTY.ExtendedProperties.Add("Decimals", "0");
				_columnIQTY.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnIQTY);
				
				_columnINUM = new DataColumn("INUM", typeof(string), "", MappingType.Element);
				_columnINUM.AllowDBNull = true;
				_columnINUM.Caption = "Inum";
				_columnINUM.MaxLength = 3;
				_columnINUM.Unique = false;
				_columnINUM.DefaultValue = Convert.DBNull;
				_columnINUM.ExtendedProperties.Add("IsKey", "false");
				_columnINUM.ExtendedProperties.Add("ReadOnly", "false");
				_columnINUM.ExtendedProperties.Add("Description", "Inum");
				_columnINUM.ExtendedProperties.Add("Length", "3");
				_columnINUM.ExtendedProperties.Add("Decimals", "0");
				_columnINUM.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnINUM);
				
				_columnQTY = new DataColumn("QTY", typeof(string), "", MappingType.Element);
				_columnQTY.AllowDBNull = true;
				_columnQTY.Caption = "Qty";
				_columnQTY.MaxLength = 20;
				_columnQTY.Unique = false;
				_columnQTY.DefaultValue = Convert.DBNull;
				_columnQTY.ExtendedProperties.Add("IsKey", "false");
				_columnQTY.ExtendedProperties.Add("ReadOnly", "false");
				_columnQTY.ExtendedProperties.Add("Description", "Qty");
				_columnQTY.ExtendedProperties.Add("Length", "20");
				_columnQTY.ExtendedProperties.Add("Decimals", "0");
				_columnQTY.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnQTY);
				
				_columnUM = new DataColumn("UM", typeof(string), "", MappingType.Element);
				_columnUM.AllowDBNull = true;
				_columnUM.Caption = "Um";
				_columnUM.MaxLength = 3;
				_columnUM.Unique = false;
				_columnUM.DefaultValue = Convert.DBNull;
				_columnUM.ExtendedProperties.Add("IsKey", "false");
				_columnUM.ExtendedProperties.Add("ReadOnly", "false");
				_columnUM.ExtendedProperties.Add("Description", "Um");
				_columnUM.ExtendedProperties.Add("Length", "3");
				_columnUM.ExtendedProperties.Add("Decimals", "0");
				_columnUM.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnUM);
				
				_columnLDES = new DataColumn("LDES", typeof(string), "", MappingType.Element);
				_columnLDES.AllowDBNull = true;
				_columnLDES.Caption = "Ldes";
				_columnLDES.MaxLength = 250;
				_columnLDES.Unique = false;
				_columnLDES.DefaultValue = Convert.DBNull;
				_columnLDES.ExtendedProperties.Add("IsKey", "false");
				_columnLDES.ExtendedProperties.Add("ReadOnly", "false");
				_columnLDES.ExtendedProperties.Add("Description", "Ldes");
				_columnLDES.ExtendedProperties.Add("Length", "250");
				_columnLDES.ExtendedProperties.Add("Decimals", "0");
				_columnLDES.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnLDES);
				
				_columnSDES = new DataColumn("SDES", typeof(string), "", MappingType.Element);
				_columnSDES.AllowDBNull = true;
				_columnSDES.Caption = "Sdes";
				_columnSDES.MaxLength = 100;
				_columnSDES.Unique = false;
				_columnSDES.DefaultValue = Convert.DBNull;
				_columnSDES.ExtendedProperties.Add("IsKey", "false");
				_columnSDES.ExtendedProperties.Add("ReadOnly", "false");
				_columnSDES.ExtendedProperties.Add("Description", "Sdes");
				_columnSDES.ExtendedProperties.Add("Length", "100");
				_columnSDES.ExtendedProperties.Add("Decimals", "0");
				_columnSDES.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnSDES);
				
				_columnLPOS = new DataColumn("LPOS", typeof(int), "", MappingType.Element);
				_columnLPOS.AllowDBNull = true;
				_columnLPOS.Caption = "Lpos";
				_columnLPOS.Unique = false;
				_columnLPOS.DefaultValue = Convert.DBNull;
				_columnLPOS.ExtendedProperties.Add("IsKey", "false");
				_columnLPOS.ExtendedProperties.Add("ReadOnly", "false");
				_columnLPOS.ExtendedProperties.Add("Description", "Lpos");
				_columnLPOS.ExtendedProperties.Add("Decimals", "0");
				_columnLPOS.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnLPOS);
				
				_columnVCK1 = new DataColumn("VCK1", typeof(string), "", MappingType.Element);
				_columnVCK1.AllowDBNull = true;
				_columnVCK1.Caption = "Vck 1";
				_columnVCK1.MaxLength = 50;
				_columnVCK1.Unique = false;
				_columnVCK1.DefaultValue = Convert.DBNull;
				_columnVCK1.ExtendedProperties.Add("IsKey", "false");
				_columnVCK1.ExtendedProperties.Add("ReadOnly", "false");
				_columnVCK1.ExtendedProperties.Add("Description", "Vck 1");
				_columnVCK1.ExtendedProperties.Add("Length", "50");
				_columnVCK1.ExtendedProperties.Add("Decimals", "0");
				_columnVCK1.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnVCK1);
				
				_columnEXPR1 = new DataColumn("EXPR1", typeof(string), "", MappingType.Element);
				_columnEXPR1.AllowDBNull = true;
				_columnEXPR1.Caption = "Expr 1";
				_columnEXPR1.MaxLength = 40;
				_columnEXPR1.Unique = false;
				_columnEXPR1.DefaultValue = Convert.DBNull;
				_columnEXPR1.ExtendedProperties.Add("IsKey", "false");
				_columnEXPR1.ExtendedProperties.Add("ReadOnly", "false");
				_columnEXPR1.ExtendedProperties.Add("Description", "Expr 1");
				_columnEXPR1.ExtendedProperties.Add("Length", "40");
				_columnEXPR1.ExtendedProperties.Add("Decimals", "0");
				_columnEXPR1.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnEXPR1);
				
				_columnSUBSTATUS = new DataColumn("SUBSTATUS", typeof(string), "", MappingType.Element);
				_columnSUBSTATUS.AllowDBNull = true;
				_columnSUBSTATUS.Caption = "Substatus";
				_columnSUBSTATUS.MaxLength = -1;
				_columnSUBSTATUS.Unique = false;
				_columnSUBSTATUS.DefaultValue = Convert.DBNull;
				_columnSUBSTATUS.ExtendedProperties.Add("IsKey", "false");
				_columnSUBSTATUS.ExtendedProperties.Add("ReadOnly", "false");
				_columnSUBSTATUS.ExtendedProperties.Add("Description", "Substatus");
				_columnSUBSTATUS.ExtendedProperties.Add("Length", "-1");
				_columnSUBSTATUS.ExtendedProperties.Add("Decimals", "0");
				_columnSUBSTATUS.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnSUBSTATUS);
				
				_columnSTATUS = new DataColumn("STATUS", typeof(string), "", MappingType.Element);
				_columnSTATUS.AllowDBNull = true;
				_columnSTATUS.Caption = "Status";
				_columnSTATUS.MaxLength = 50;
				_columnSTATUS.Unique = false;
				_columnSTATUS.DefaultValue = Convert.DBNull;
				_columnSTATUS.ExtendedProperties.Add("IsKey", "false");
				_columnSTATUS.ExtendedProperties.Add("ReadOnly", "false");
				_columnSTATUS.ExtendedProperties.Add("Description", "Status");
				_columnSTATUS.ExtendedProperties.Add("Length", "50");
				_columnSTATUS.ExtendedProperties.Add("Decimals", "0");
				_columnSTATUS.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnSTATUS);
				
				_columnFUSER = new DataColumn("FUSER", typeof(string), "", MappingType.Element);
				_columnFUSER.AllowDBNull = true;
				_columnFUSER.Caption = "Fuser";
				_columnFUSER.MaxLength = 50;
				_columnFUSER.Unique = false;
				_columnFUSER.DefaultValue = Convert.DBNull;
				_columnFUSER.ExtendedProperties.Add("IsKey", "false");
				_columnFUSER.ExtendedProperties.Add("ReadOnly", "false");
				_columnFUSER.ExtendedProperties.Add("Description", "Fuser");
				_columnFUSER.ExtendedProperties.Add("Length", "50");
				_columnFUSER.ExtendedProperties.Add("Decimals", "0");
				_columnFUSER.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnFUSER);
				
				_columnFDATE = new DataColumn("FDATE", typeof(DateTime), "", MappingType.Element);
				_columnFDATE.AllowDBNull = true;
				_columnFDATE.Caption = "Fdate";
				_columnFDATE.Unique = false;
				_columnFDATE.DefaultValue = Convert.DBNull;
				_columnFDATE.ExtendedProperties.Add("IsKey", "false");
				_columnFDATE.ExtendedProperties.Add("ReadOnly", "false");
				_columnFDATE.ExtendedProperties.Add("Description", "Fdate");
				_columnFDATE.ExtendedProperties.Add("Decimals", "0");
				_columnFDATE.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnFDATE);
				
				_columnLUSER = new DataColumn("LUSER", typeof(string), "", MappingType.Element);
				_columnLUSER.AllowDBNull = true;
				_columnLUSER.Caption = "Luser";
				_columnLUSER.MaxLength = 50;
				_columnLUSER.Unique = false;
				_columnLUSER.DefaultValue = Convert.DBNull;
				_columnLUSER.ExtendedProperties.Add("IsKey", "false");
				_columnLUSER.ExtendedProperties.Add("ReadOnly", "false");
				_columnLUSER.ExtendedProperties.Add("Description", "Luser");
				_columnLUSER.ExtendedProperties.Add("Length", "50");
				_columnLUSER.ExtendedProperties.Add("Decimals", "0");
				_columnLUSER.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnLUSER);
				
				_columnLDATE = new DataColumn("LDATE", typeof(DateTime), "", MappingType.Element);
				_columnLDATE.AllowDBNull = true;
				_columnLDATE.Caption = "Ldate";
				_columnLDATE.Unique = false;
				_columnLDATE.DefaultValue = Convert.DBNull;
				_columnLDATE.ExtendedProperties.Add("IsKey", "false");
				_columnLDATE.ExtendedProperties.Add("ReadOnly", "false");
				_columnLDATE.ExtendedProperties.Add("Description", "Ldate");
				_columnLDATE.ExtendedProperties.Add("Decimals", "0");
				_columnLDATE.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnLDATE);
				
				_columnUID = new DataColumn("UID", typeof(string), "", MappingType.Element);
				_columnUID.AllowDBNull = true;
				_columnUID.Caption = "Uid";
				_columnUID.MaxLength = 256;
				_columnUID.Unique = false;
				_columnUID.DefaultValue = Convert.DBNull;
				_columnUID.ExtendedProperties.Add("IsKey", "false");
				_columnUID.ExtendedProperties.Add("ReadOnly", "false");
				_columnUID.ExtendedProperties.Add("Description", "Uid");
				_columnUID.ExtendedProperties.Add("Length", "256");
				_columnUID.ExtendedProperties.Add("Decimals", "0");
				_columnUID.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnUID);
				
			}
			
			public GTARRow NewGTARRow()
			{
				GTARRow rowGTARRow = ((GTARRow)(this.NewRow()));
				return rowGTARRow;
			}
			
			protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
			{
				return new GTARRow(builder);
			}
			
			protected override Type GetRowType()
			{
				return typeof(GTARRow);
			}
			
			protected override void OnRowChanged(DataRowChangeEventArgs e)
			{
				base.OnRowChanged(e);
				if (this.GTARRowChanged != null)
				{
					this.GTARRowChanged(this, new GTARRowChangeEventArgs(((GTARRow)(e.Row)), e.Action));
				}
			}
			
			protected override void OnRowChanging(DataRowChangeEventArgs e)
			{
				base.OnRowChanging(e);
				if (this.GTARRowChanging != null)
				{
					this.GTARRowChanging(this, new GTARRowChangeEventArgs(((GTARRow)(e.Row)), e.Action));
				}
			}
			
			protected override void OnRowDeleted(DataRowChangeEventArgs e)
			{
				base.OnRowDeleted(e);
				if (this.GTARRowDeleted != null)
				{
					this.GTARRowDeleted(this, new GTARRowChangeEventArgs(((GTARRow)(e.Row)), e.Action));
				}
			}
			
			protected override void OnRowDeleting(DataRowChangeEventArgs e)
			{
				base.OnRowDeleting(e);
				if (this.GTARRowDeleting != null)
				{
					this.GTARRowDeleting(this, new GTARRowChangeEventArgs(((GTARRow)(e.Row)), e.Action));
				}
			}
			
			public void RemoveGTARRow(GTARRow row)
			{
				this.Rows.Remove(row);
			}
		}
		
		public class GTARRow: DataRow
		{
			private GTARDataTable _tableGTAR;
			
			internal GTARRow(DataRowBuilder rb): base(rb)
			{
				_tableGTAR = ((GTARDataTable)(this.Table));
			}
			
			/// <summary>
			/// Gets or sets the value of SM property
			/// </summary>
			public string SM
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTAR.SMColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value SM because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.SMColumn] = value;
				}
			}
			
			public bool IsSMNull()
			{
				return this.IsNull(_tableGTAR.SMColumn);
			}
			
			public void SetSMNull()
			{
				this[_tableGTAR.SMColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of GTPRE property
			/// </summary>
			public string GTPRE
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTAR.GTPREColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value GTPRE because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.GTPREColumn] = value;
				}
			}
			
			public bool IsGTPRENull()
			{
				return this.IsNull(_tableGTAR.GTPREColumn);
			}
			
			public void SetGTPRENull()
			{
				this[_tableGTAR.GTPREColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of GTKEY property
			/// </summary>
			public string GTKEY
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTAR.GTKEYColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value GTKEY because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.GTKEYColumn] = value;
				}
			}
			
			public bool IsGTKEYNull()
			{
				return this.IsNull(_tableGTAR.GTKEYColumn);
			}
			
			public void SetGTKEYNull()
			{
				this[_tableGTAR.GTKEYColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of POS property
			/// </summary>
			public int POS
			{
				get
				{
					try
					{
						return ((int)(this[_tableGTAR.POSColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value POS because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.POSColumn] = value;
				}
			}
			
			public bool IsPOSNull()
			{
				return this.IsNull(_tableGTAR.POSColumn);
			}
			
			public void SetPOSNull()
			{
				this[_tableGTAR.POSColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of PPKEY property
			/// </summary>
			public string PPKEY
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTAR.PPKEYColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value PPKEY because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.PPKEYColumn] = value;
				}
			}
			
			public bool IsPPKEYNull()
			{
				return this.IsNull(_tableGTAR.PPKEYColumn);
			}
			
			public void SetPPKEYNull()
			{
				this[_tableGTAR.PPKEYColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of PPTKEY property
			/// </summary>
			public string PPTKEY
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTAR.PPTKEYColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value PPTKEY because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.PPTKEYColumn] = value;
				}
			}
			
			public bool IsPPTKEYNull()
			{
				return this.IsNull(_tableGTAR.PPTKEYColumn);
			}
			
			public void SetPPTKEYNull()
			{
				this[_tableGTAR.PPTKEYColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of GAPKEY property
			/// </summary>
			public string GAPKEY
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTAR.GAPKEYColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value GAPKEY because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.GAPKEYColumn] = value;
				}
			}
			
			public bool IsGAPKEYNull()
			{
				return this.IsNull(_tableGTAR.GAPKEYColumn);
			}
			
			public void SetGAPKEYNull()
			{
				this[_tableGTAR.GAPKEYColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of MVTKEY property
			/// </summary>
			public string MVTKEY
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTAR.MVTKEYColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value MVTKEY because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.MVTKEYColumn] = value;
				}
			}
			
			public bool IsMVTKEYNull()
			{
				return this.IsNull(_tableGTAR.MVTKEYColumn);
			}
			
			public void SetMVTKEYNull()
			{
				this[_tableGTAR.MVTKEYColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of SREAL property
			/// </summary>
			public string SREAL
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTAR.SREALColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value SREAL because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.SREALColumn] = value;
				}
			}
			
			public bool IsSREALNull()
			{
				return this.IsNull(_tableGTAR.SREALColumn);
			}
			
			public void SetSREALNull()
			{
				this[_tableGTAR.SREALColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of SGTPRE property
			/// </summary>
			public string SGTPRE
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTAR.SGTPREColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value SGTPRE because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.SGTPREColumn] = value;
				}
			}
			
			public bool IsSGTPRENull()
			{
				return this.IsNull(_tableGTAR.SGTPREColumn);
			}
			
			public void SetSGTPRENull()
			{
				this[_tableGTAR.SGTPREColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of SGTKEY property
			/// </summary>
			public string SGTKEY
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTAR.SGTKEYColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value SGTKEY because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.SGTKEYColumn] = value;
				}
			}
			
			public bool IsSGTKEYNull()
			{
				return this.IsNull(_tableGTAR.SGTKEYColumn);
			}
			
			public void SetSGTKEYNull()
			{
				this[_tableGTAR.SGTKEYColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of SMULTIKEY property
			/// </summary>
			public string SMULTIKEY
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTAR.SMULTIKEYColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value SMULTIKEY because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.SMULTIKEYColumn] = value;
				}
			}
			
			public bool IsSMULTIKEYNull()
			{
				return this.IsNull(_tableGTAR.SMULTIKEYColumn);
			}
			
			public void SetSMULTIKEYNull()
			{
				this[_tableGTAR.SMULTIKEYColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of SFKEY property
			/// </summary>
			public string SFKEY
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTAR.SFKEYColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value SFKEY because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.SFKEYColumn] = value;
				}
			}
			
			public bool IsSFKEYNull()
			{
				return this.IsNull(_tableGTAR.SFKEYColumn);
			}
			
			public void SetSFKEYNull()
			{
				this[_tableGTAR.SFKEYColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of SGDKEYG property
			/// </summary>
			public string SGDKEYG
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTAR.SGDKEYGColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value SGDKEYG because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.SGDKEYGColumn] = value;
				}
			}
			
			public bool IsSGDKEYGNull()
			{
				return this.IsNull(_tableGTAR.SGDKEYGColumn);
			}
			
			public void SetSGDKEYGNull()
			{
				this[_tableGTAR.SGDKEYGColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of IQTY property
			/// </summary>
			public string IQTY
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTAR.IQTYColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value IQTY because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.IQTYColumn] = value;
				}
			}
			
			public bool IsIQTYNull()
			{
				return this.IsNull(_tableGTAR.IQTYColumn);
			}
			
			public void SetIQTYNull()
			{
				this[_tableGTAR.IQTYColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of INUM property
			/// </summary>
			public string INUM
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTAR.INUMColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value INUM because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.INUMColumn] = value;
				}
			}
			
			public bool IsINUMNull()
			{
				return this.IsNull(_tableGTAR.INUMColumn);
			}
			
			public void SetINUMNull()
			{
				this[_tableGTAR.INUMColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of QTY property
			/// </summary>
			public string QTY
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTAR.QTYColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value QTY because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.QTYColumn] = value;
				}
			}
			
			public bool IsQTYNull()
			{
				return this.IsNull(_tableGTAR.QTYColumn);
			}
			
			public void SetQTYNull()
			{
				this[_tableGTAR.QTYColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of UM property
			/// </summary>
			public string UM
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTAR.UMColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value UM because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.UMColumn] = value;
				}
			}
			
			public bool IsUMNull()
			{
				return this.IsNull(_tableGTAR.UMColumn);
			}
			
			public void SetUMNull()
			{
				this[_tableGTAR.UMColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of LDES property
			/// </summary>
			public string LDES
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTAR.LDESColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value LDES because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.LDESColumn] = value;
				}
			}
			
			public bool IsLDESNull()
			{
				return this.IsNull(_tableGTAR.LDESColumn);
			}
			
			public void SetLDESNull()
			{
				this[_tableGTAR.LDESColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of SDES property
			/// </summary>
			public string SDES
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTAR.SDESColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value SDES because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.SDESColumn] = value;
				}
			}
			
			public bool IsSDESNull()
			{
				return this.IsNull(_tableGTAR.SDESColumn);
			}
			
			public void SetSDESNull()
			{
				this[_tableGTAR.SDESColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of LPOS property
			/// </summary>
			public int LPOS
			{
				get
				{
					try
					{
						return ((int)(this[_tableGTAR.LPOSColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value LPOS because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.LPOSColumn] = value;
				}
			}
			
			public bool IsLPOSNull()
			{
				return this.IsNull(_tableGTAR.LPOSColumn);
			}
			
			public void SetLPOSNull()
			{
				this[_tableGTAR.LPOSColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of VCK1 property
			/// </summary>
			public string VCK1
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTAR.VCK1Column]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value VCK1 because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.VCK1Column] = value;
				}
			}
			
			public bool IsVCK1Null()
			{
				return this.IsNull(_tableGTAR.VCK1Column);
			}
			
			public void SetVCK1Null()
			{
				this[_tableGTAR.VCK1Column] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of EXPR1 property
			/// </summary>
			public string EXPR1
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTAR.EXPR1Column]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value EXPR1 because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.EXPR1Column] = value;
				}
			}
			
			public bool IsEXPR1Null()
			{
				return this.IsNull(_tableGTAR.EXPR1Column);
			}
			
			public void SetEXPR1Null()
			{
				this[_tableGTAR.EXPR1Column] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of SUBSTATUS property
			/// </summary>
			public string SUBSTATUS
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTAR.SUBSTATUSColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value SUBSTATUS because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.SUBSTATUSColumn] = value;
				}
			}
			
			public bool IsSUBSTATUSNull()
			{
				return this.IsNull(_tableGTAR.SUBSTATUSColumn);
			}
			
			public void SetSUBSTATUSNull()
			{
				this[_tableGTAR.SUBSTATUSColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of STATUS property
			/// </summary>
			public string STATUS
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTAR.STATUSColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value STATUS because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.STATUSColumn] = value;
				}
			}
			
			public bool IsSTATUSNull()
			{
				return this.IsNull(_tableGTAR.STATUSColumn);
			}
			
			public void SetSTATUSNull()
			{
				this[_tableGTAR.STATUSColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of FUSER property
			/// </summary>
			public string FUSER
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTAR.FUSERColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value FUSER because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.FUSERColumn] = value;
				}
			}
			
			public bool IsFUSERNull()
			{
				return this.IsNull(_tableGTAR.FUSERColumn);
			}
			
			public void SetFUSERNull()
			{
				this[_tableGTAR.FUSERColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of FDATE property
			/// </summary>
			public DateTime FDATE
			{
				get
				{
					try
					{
						return ((DateTime)(this[_tableGTAR.FDATEColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value FDATE because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.FDATEColumn] = value;
				}
			}
			
			public bool IsFDATENull()
			{
				return this.IsNull(_tableGTAR.FDATEColumn);
			}
			
			public void SetFDATENull()
			{
				this[_tableGTAR.FDATEColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of LUSER property
			/// </summary>
			public string LUSER
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTAR.LUSERColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value LUSER because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.LUSERColumn] = value;
				}
			}
			
			public bool IsLUSERNull()
			{
				return this.IsNull(_tableGTAR.LUSERColumn);
			}
			
			public void SetLUSERNull()
			{
				this[_tableGTAR.LUSERColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of LDATE property
			/// </summary>
			public DateTime LDATE
			{
				get
				{
					try
					{
						return ((DateTime)(this[_tableGTAR.LDATEColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value LDATE because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.LDATEColumn] = value;
				}
			}
			
			public bool IsLDATENull()
			{
				return this.IsNull(_tableGTAR.LDATEColumn);
			}
			
			public void SetLDATENull()
			{
				this[_tableGTAR.LDATEColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of UID property
			/// </summary>
			public string UID
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTAR.UIDColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value UID because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTAR.UIDColumn] = value;
				}
			}
			
			public bool IsUIDNull()
			{
				return this.IsNull(_tableGTAR.UIDColumn);
			}
			
			public void SetUIDNull()
			{
				this[_tableGTAR.UIDColumn] = Convert.DBNull;
			}
			
		}
		
		public class GTARRowChangeEventArgs: EventArgs
		{
			private GTARRow _eventRow;
			private System.Data.DataRowAction _eventAction;
			
			public GTARRowChangeEventArgs(GTARRow row, DataRowAction action)
			{
				_eventRow = row;
				_eventAction = action;
			}
			
			public GTARRow Row
			{
				get
				{
					return _eventRow;
				}
			}
			
			public DataRowAction Action
			{
				get
				{
					return _eventAction;
				}
			}
		}
	}
	#endregion
    #region GTARQueryCondDataSet
	[Serializable()]
	[DesignerCategoryAttribute("code")]
	[System.Diagnostics.DebuggerStepThrough()]
	[ToolboxItem(true)]
	public class GTARQueryCondDataSet: DataSet
	{
		private GTARQueryCondDataTable _tableGTARQueryCond;
		
		[DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Content)]
		public GTARQueryCondDataTable GTARQueryCond
		{
			get
			{
				return this._tableGTARQueryCond;
			}
		}
		
		public GTARQueryCondDataSet()
		{
			this.InitClass();
		}
		
		protected override XmlSchema GetSchemaSerializable() 
		{
			MemoryStream stream = new MemoryStream();
			this.WriteXmlSchema(new	XmlTextWriter(stream, null));
			stream.Position = 0;
			return XmlSchema.Read(new XmlTextReader(stream), null);
		}
		
		protected override void	ReadXmlSerializable(XmlReader reader) 
		{
			this.Reset();
			DataSet ds = new DataSet();
			ds.ReadXml(reader);
			if ((ds.Tables["GTARQueryCond"] != null))
			{
				this.Tables.Add(new GTARQueryCondDataTable(ds.Tables["GTARQueryCond"]));
			}
			this.DataSetName = ds.DataSetName;
			this.Prefix = ds.Prefix;
			this.Namespace = ds.Namespace;
			this.Locale = ds.Locale;
			this.CaseSensitive = ds.CaseSensitive;
			this.EnforceConstraints = ds.EnforceConstraints;
			this.Merge(ds, false, System.Data.MissingSchemaAction.Add);
			this.InitVars();
		}
		
		protected GTARQueryCondDataSet(SerializationInfo info, StreamingContext context)
		{
			string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
			if ((strSchema != null))
			{
				DataSet ds = new DataSet();
				ds.ReadXmlSchema(new XmlTextReader(new System.IO.StringReader(strSchema)));
				if ((ds.Tables["GTARQueryCond"] != null))
				{
					this.Tables.Add(new GTARQueryCondDataTable(ds.Tables["GTARQueryCond"]));
				}
				this.DataSetName = ds.DataSetName;
				this.Prefix = ds.Prefix;
				this.Namespace = ds.Namespace;
				this.Locale = ds.Locale;
				this.CaseSensitive = ds.CaseSensitive;
				this.EnforceConstraints = ds.EnforceConstraints;
				this.Merge(ds, false, System.Data.MissingSchemaAction.Add);
				this.InitVars();
			}
			else
			{
				this.InitClass();
			}
			this.GetSerializationData(info, context);
		}
		
		private void InitClass()
		{
			this.DataSetName = "GTARQueryCondDataSet";
			_tableGTARQueryCond = new GTARQueryCondDataTable();
			this.Tables.Add(_tableGTARQueryCond);
			this.ExtendedProperties.Add("ObjectName", "GTARQueryCond");
			this.ExtendedProperties.Add("ObjectDescription", "GTARQueryCond");
			this.ExtendedProperties.Add("NameSpace", "");
		}
		
		public override DataSet Clone()
		{
			GTARQueryCondDataSet cln = ((GTARQueryCondDataSet)(base.Clone()));
			cln.InitVars();
			return cln;
		}
		
		internal void InitVars()
		{
			_tableGTARQueryCond = ((GTARQueryCondDataTable)(this.Tables["GTARQueryCond"]));
			if (_tableGTARQueryCond != null)
			{
				_tableGTARQueryCond.InitVars();
			}
		}
		
		protected override bool ShouldSerializeTables()
		{
			return false;
		}
		
		protected override bool ShouldSerializeRelations()
		{
			return false;
		}
		
		private bool ShouldSerializeGTARQueryCond()
		{
			return false;
		}
		
		public delegate void GTARQueryCondRowChangeEventHandler(object sender, GTARQueryCondRowChangeEventArgs e);
		
		[Serializable()]
		public class GTARQueryCondDataTable: DataTable, System.Collections.IEnumerable
		{
			private DataColumn _columnQUERYTYPE;
			private DataColumn _columnCONDTYPE;
			private DataColumn _columnREASON1;
			private DataColumn _columnFKREAL;
			private DataColumn _columnSM;
			private DataColumn _columnKREAL;
			private DataColumn _columnGTPRE;
			private DataColumn _columnGTKEY;
			private DataColumn _columnPOS;
			private DataColumn _columnPROCESSPOINTKEY;
			private DataColumn _columnGOODSASSEMBLEPOINTTYPEKEY;
			private DataColumn _columnGOODSASSEMBLEPOINTKEY;
			private DataColumn _columnGOODSMOVEMENTTYPEKEY;
			private DataColumn _columnSKREAL;
			private DataColumn _columnSGTPRE;
			private DataColumn _columnSGTKEY;
			private DataColumn _columnSMULTIKEY;
			private DataColumn _columnSFOREIGNKEY;
			private DataColumn _columnSGOODSKEYGENERATION;
			private DataColumn _columnINQUANTITY;
			private DataColumn _columnINUM;
			private DataColumn _columnQUANTITY;
			private DataColumn _columnUM;
			private DataColumn _columnLDES;
			private DataColumn _columnSDES;
			private DataColumn _columnLPOS;
			private DataColumn _columnVALUECONTROLTYPEKEY;
			private DataColumn _columnEXPR1;
			private DataColumn _columnSUBSTATUS;
			private DataColumn _columnSTATUS;
			private DataColumn _columnFUSER;
			private DataColumn _columnFDATE;
			private DataColumn _columnLUSER;
			private DataColumn _columnLDATE;
			private DataColumn _columnUID;
			
			internal GTARQueryCondDataTable(): base("GTARQueryCond")
			{
				this.InitClass();
			}
			
			protected GTARQueryCondDataTable(SerializationInfo info, StreamingContext context): base(info, context)
			{
				this.InitVars();
			}
			
			internal GTARQueryCondDataTable(DataTable table): base(table.TableName)
			{
				if (table.CaseSensitive != table.DataSet.CaseSensitive)
				{
					this.CaseSensitive = table.CaseSensitive;
				}
				if (table.Locale.ToString() != table.DataSet.Locale.ToString())
				{
					this.Locale = table.Locale;
				}
				if (table.Namespace != table.DataSet.Namespace)
				{
					this.Namespace = table.Namespace;
				}
				this.Prefix = table.Prefix;
				this.MinimumCapacity = table.MinimumCapacity;
				this.DisplayExpression = table.DisplayExpression;
			}
			
			public int Count
			{
				get
				{
					return this.Rows.Count;
				}
			}
			
			public DataColumn QUERYTYPEColumn
			{
				get
				{
					return _columnQUERYTYPE;
				}
			}
			
			public DataColumn CONDTYPEColumn
			{
				get
				{
					return _columnCONDTYPE;
				}
			}
			
			public DataColumn REASON1Column
			{
				get
				{
					return _columnREASON1;
				}
			}
			
			public DataColumn FKREALColumn
			{
				get
				{
					return _columnFKREAL;
				}
			}
			
			public DataColumn SMColumn
			{
				get
				{
					return _columnSM;
				}
			}
			
			public DataColumn KREALColumn
			{
				get
				{
					return _columnKREAL;
				}
			}
			
			public DataColumn GTPREColumn
			{
				get
				{
					return _columnGTPRE;
				}
			}
			
			public DataColumn GTKEYColumn
			{
				get
				{
					return _columnGTKEY;
				}
			}
			
			public DataColumn POSColumn
			{
				get
				{
					return _columnPOS;
				}
			}
			
			public DataColumn PROCESSPOINTKEYColumn
			{
				get
				{
					return _columnPROCESSPOINTKEY;
				}
			}
			
			public DataColumn GOODSASSEMBLEPOINTTYPEKEYColumn
			{
				get
				{
					return _columnGOODSASSEMBLEPOINTTYPEKEY;
				}
			}
			
			public DataColumn GOODSASSEMBLEPOINTKEYColumn
			{
				get
				{
					return _columnGOODSASSEMBLEPOINTKEY;
				}
			}
			
			public DataColumn GOODSMOVEMENTTYPEKEYColumn
			{
				get
				{
					return _columnGOODSMOVEMENTTYPEKEY;
				}
			}
			
			public DataColumn SKREALColumn
			{
				get
				{
					return _columnSKREAL;
				}
			}
			
			public DataColumn SGTPREColumn
			{
				get
				{
					return _columnSGTPRE;
				}
			}
			
			public DataColumn SGTKEYColumn
			{
				get
				{
					return _columnSGTKEY;
				}
			}
			
			public DataColumn SMULTIKEYColumn
			{
				get
				{
					return _columnSMULTIKEY;
				}
			}
			
			public DataColumn SFOREIGNKEYColumn
			{
				get
				{
					return _columnSFOREIGNKEY;
				}
			}
			
			public DataColumn SGOODSKEYGENERATIONColumn
			{
				get
				{
					return _columnSGOODSKEYGENERATION;
				}
			}
			
			public DataColumn INQUANTITYColumn
			{
				get
				{
					return _columnINQUANTITY;
				}
			}
			
			public DataColumn INUMColumn
			{
				get
				{
					return _columnINUM;
				}
			}
			
			public DataColumn QUANTITYColumn
			{
				get
				{
					return _columnQUANTITY;
				}
			}
			
			public DataColumn UMColumn
			{
				get
				{
					return _columnUM;
				}
			}
			
			public DataColumn LDESColumn
			{
				get
				{
					return _columnLDES;
				}
			}
			
			public DataColumn SDESColumn
			{
				get
				{
					return _columnSDES;
				}
			}
			
			public DataColumn LPOSColumn
			{
				get
				{
					return _columnLPOS;
				}
			}
			
			public DataColumn VALUECONTROLTYPEKEYColumn
			{
				get
				{
					return _columnVALUECONTROLTYPEKEY;
				}
			}
			
			public DataColumn EXPR1Column
			{
				get
				{
					return _columnEXPR1;
				}
			}
			
			public DataColumn SUBSTATUSColumn
			{
				get
				{
					return _columnSUBSTATUS;
				}
			}
			
			public DataColumn STATUSColumn
			{
				get
				{
					return _columnSTATUS;
				}
			}
			
			public DataColumn FUSERColumn
			{
				get
				{
					return _columnFUSER;
				}
			}
			
			public DataColumn FDATEColumn
			{
				get
				{
					return _columnFDATE;
				}
			}
			
			public DataColumn LUSERColumn
			{
				get
				{
					return _columnLUSER;
				}
			}
			
			public DataColumn LDATEColumn
			{
				get
				{
					return _columnLDATE;
				}
			}
			
			public DataColumn UIDColumn
			{
				get
				{
					return _columnUID;
				}
			}
			
			public GTARQueryCondRow this[int index]
			{
				get
				{
					return ((GTARQueryCondRow)(this.Rows[index]));
				}
			}
			
			public event GTARQueryCondRowChangeEventHandler GTARQueryCondRowChanged;
			public event GTARQueryCondRowChangeEventHandler GTARQueryCondRowChanging;
			public event GTARQueryCondRowChangeEventHandler GTARQueryCondRowDeleted;
			public event GTARQueryCondRowChangeEventHandler GTARQueryCondRowDeleting;
			
			public void AddGTARQueryCondRow(GTARQueryCondRow row)
			{
				this.Rows.Add(row);
			}
			
			public GTARQueryCondRow AddGTARQueryCondRow(
					string querytype,
					string condtype,
					string reason1,
					string fkreal,
					string sm,
					string kreal,
					string gtpre,
					string gtkey,
					int pos,
					string processpointkey,
					string goodsassemblepointtypekey,
					string goodsassemblepointkey,
					string goodsmovementtypekey,
					string skreal,
					string sgtpre,
					string sgtkey,
					string smultikey,
					string sforeignkey,
					string sgoodskeygeneration,
					string inquantity,
					string inum,
					string quantity,
					string um,
					string ldes,
					string sdes,
					int lpos,
					string valuecontroltypekey,
					string expr1,
					string substatus,
					string status,
					string fuser,
					DateTime fdate,
					string luser,
					DateTime ldate,
					string uid
				)
			{
				GTARQueryCondRow rowGTARQueryCondRow = ((GTARQueryCondRow)(this.NewRow()));
				rowGTARQueryCondRow["QUERYTYPE"] = querytype;
				rowGTARQueryCondRow["CONDTYPE"] = condtype;
				rowGTARQueryCondRow["REASON1"] = reason1;
				rowGTARQueryCondRow["FKREAL"] = fkreal;
				rowGTARQueryCondRow["SM"] = sm;
				rowGTARQueryCondRow["KREAL"] = kreal;
				rowGTARQueryCondRow["GTPRE"] = gtpre;
				rowGTARQueryCondRow["GTKEY"] = gtkey;
				rowGTARQueryCondRow["POS"] = pos;
				rowGTARQueryCondRow["PROCESSPOINTKEY"] = processpointkey;
				rowGTARQueryCondRow["GOODSASSEMBLEPOINTTYPEKEY"] = goodsassemblepointtypekey;
				rowGTARQueryCondRow["GOODSASSEMBLEPOINTKEY"] = goodsassemblepointkey;
				rowGTARQueryCondRow["GOODSMOVEMENTTYPEKEY"] = goodsmovementtypekey;
				rowGTARQueryCondRow["SKREAL"] = skreal;
				rowGTARQueryCondRow["SGTPRE"] = sgtpre;
				rowGTARQueryCondRow["SGTKEY"] = sgtkey;
				rowGTARQueryCondRow["SMULTIKEY"] = smultikey;
				rowGTARQueryCondRow["SFOREIGNKEY"] = sforeignkey;
				rowGTARQueryCondRow["SGOODSKEYGENERATION"] = sgoodskeygeneration;
				rowGTARQueryCondRow["INQUANTITY"] = inquantity;
				rowGTARQueryCondRow["INUM"] = inum;
				rowGTARQueryCondRow["QUANTITY"] = quantity;
				rowGTARQueryCondRow["UM"] = um;
				rowGTARQueryCondRow["LDES"] = ldes;
				rowGTARQueryCondRow["SDES"] = sdes;
				rowGTARQueryCondRow["LPOS"] = lpos;
				rowGTARQueryCondRow["VALUECONTROLTYPEKEY"] = valuecontroltypekey;
				rowGTARQueryCondRow["EXPR1"] = expr1;
				rowGTARQueryCondRow["SUBSTATUS"] = substatus;
				rowGTARQueryCondRow["STATUS"] = status;
				rowGTARQueryCondRow["FUSER"] = fuser;
				rowGTARQueryCondRow["FDATE"] = fdate;
				rowGTARQueryCondRow["LUSER"] = luser;
				rowGTARQueryCondRow["LDATE"] = ldate;
				rowGTARQueryCondRow["UID"] = uid;
				this.Rows.Add(rowGTARQueryCondRow);
				return rowGTARQueryCondRow;
			} 
			 
			public IEnumerator GetEnumerator()
			{
				return this.Rows.GetEnumerator();
			}
			
			public override DataTable Clone()
			{
				GTARQueryCondDataTable cln = ((GTARQueryCondDataTable)(base.Clone()));
				cln.InitVars();
				return cln;
			}
			
			internal void InitVars()
			{
				_columnQUERYTYPE = this.Columns["QUERYTYPE"];
				_columnCONDTYPE = this.Columns["CONDTYPE"];
				_columnREASON1 = this.Columns["REASON1"];
				_columnFKREAL = this.Columns["FKREAL"];
				_columnSM = this.Columns["SM"];
				_columnKREAL = this.Columns["KREAL"];
				_columnGTPRE = this.Columns["GTPRE"];
				_columnGTKEY = this.Columns["GTKEY"];
				_columnPOS = this.Columns["POS"];
				_columnPROCESSPOINTKEY = this.Columns["PROCESSPOINTKEY"];
				_columnGOODSASSEMBLEPOINTTYPEKEY = this.Columns["GOODSASSEMBLEPOINTTYPEKEY"];
				_columnGOODSASSEMBLEPOINTKEY = this.Columns["GOODSASSEMBLEPOINTKEY"];
				_columnGOODSMOVEMENTTYPEKEY = this.Columns["GOODSMOVEMENTTYPEKEY"];
				_columnSKREAL = this.Columns["SKREAL"];
				_columnSGTPRE = this.Columns["SGTPRE"];
				_columnSGTKEY = this.Columns["SGTKEY"];
				_columnSMULTIKEY = this.Columns["SMULTIKEY"];
				_columnSFOREIGNKEY = this.Columns["SFOREIGNKEY"];
				_columnSGOODSKEYGENERATION = this.Columns["SGOODSKEYGENERATION"];
				_columnINQUANTITY = this.Columns["INQUANTITY"];
				_columnINUM = this.Columns["INUM"];
				_columnQUANTITY = this.Columns["QUANTITY"];
				_columnUM = this.Columns["UM"];
				_columnLDES = this.Columns["LDES"];
				_columnSDES = this.Columns["SDES"];
				_columnLPOS = this.Columns["LPOS"];
				_columnVALUECONTROLTYPEKEY = this.Columns["VALUECONTROLTYPEKEY"];
				_columnEXPR1 = this.Columns["EXPR1"];
				_columnSUBSTATUS = this.Columns["SUBSTATUS"];
				_columnSTATUS = this.Columns["STATUS"];
				_columnFUSER = this.Columns["FUSER"];
				_columnFDATE = this.Columns["FDATE"];
				_columnLUSER = this.Columns["LUSER"];
				_columnLDATE = this.Columns["LDATE"];
				_columnUID = this.Columns["UID"];
			}
			
			public void InitClass()
			{
				_columnQUERYTYPE = new DataColumn("QUERYTYPE", typeof(string), "", MappingType.Element);
				_columnQUERYTYPE.AllowDBNull = false;
				_columnQUERYTYPE.Caption = "Querytype";
				_columnQUERYTYPE.MaxLength = 50;
				_columnQUERYTYPE.Unique = false;
				_columnQUERYTYPE.DefaultValue = Convert.DBNull;
				_columnQUERYTYPE.ExtendedProperties.Add("IsKey", "false");
				_columnQUERYTYPE.ExtendedProperties.Add("ReadOnly", "false");
				_columnQUERYTYPE.ExtendedProperties.Add("Description", "Querytype");
				_columnQUERYTYPE.ExtendedProperties.Add("Length", "50");
				_columnQUERYTYPE.ExtendedProperties.Add("Decimals", "0");
				_columnQUERYTYPE.ExtendedProperties.Add("AllowDBNulls", "false");
				this.Columns.Add(_columnQUERYTYPE);
				
				_columnCONDTYPE = new DataColumn("CONDTYPE", typeof(string), "", MappingType.Element);
				_columnCONDTYPE.AllowDBNull = false;
				_columnCONDTYPE.Caption = "Condtype";
				_columnCONDTYPE.MaxLength = 250;
				_columnCONDTYPE.Unique = false;
				_columnCONDTYPE.DefaultValue = Convert.DBNull;
				_columnCONDTYPE.ExtendedProperties.Add("IsKey", "false");
				_columnCONDTYPE.ExtendedProperties.Add("ReadOnly", "false");
				_columnCONDTYPE.ExtendedProperties.Add("Description", "Condtype");
				_columnCONDTYPE.ExtendedProperties.Add("Length", "250");
				_columnCONDTYPE.ExtendedProperties.Add("Decimals", "0");
				_columnCONDTYPE.ExtendedProperties.Add("AllowDBNulls", "false");
				this.Columns.Add(_columnCONDTYPE);
				
				_columnREASON1 = new DataColumn("REASON1", typeof(string), "", MappingType.Element);
				_columnREASON1.AllowDBNull = true;
				_columnREASON1.Caption = "Reason 1";
				_columnREASON1.MaxLength = 100;
				_columnREASON1.Unique = false;
				_columnREASON1.DefaultValue = Convert.DBNull;
				_columnREASON1.ExtendedProperties.Add("IsKey", "false");
				_columnREASON1.ExtendedProperties.Add("ReadOnly", "false");
				_columnREASON1.ExtendedProperties.Add("Description", "Reason 1");
				_columnREASON1.ExtendedProperties.Add("Length", "100");
				_columnREASON1.ExtendedProperties.Add("Decimals", "0");
				_columnREASON1.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnREASON1);
				
				_columnFKREAL = new DataColumn("FKREAL", typeof(string), "", MappingType.Element);
				_columnFKREAL.AllowDBNull = true;
				_columnFKREAL.Caption = "Fkreal";
				_columnFKREAL.MaxLength = 100;
				_columnFKREAL.Unique = false;
				_columnFKREAL.DefaultValue = Convert.DBNull;
				_columnFKREAL.ExtendedProperties.Add("IsKey", "false");
				_columnFKREAL.ExtendedProperties.Add("ReadOnly", "false");
				_columnFKREAL.ExtendedProperties.Add("Description", "Fkreal");
				_columnFKREAL.ExtendedProperties.Add("Length", "100");
				_columnFKREAL.ExtendedProperties.Add("Decimals", "0");
				_columnFKREAL.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnFKREAL);
				
				_columnSM = new DataColumn("SM", typeof(string), "", MappingType.Element);
				_columnSM.AllowDBNull = true;
				_columnSM.Caption = "Sm";
				_columnSM.MaxLength = 10;
				_columnSM.Unique = false;
				_columnSM.DefaultValue = Convert.DBNull;
				_columnSM.ExtendedProperties.Add("IsKey", "false");
				_columnSM.ExtendedProperties.Add("ReadOnly", "false");
				_columnSM.ExtendedProperties.Add("Description", "Sm");
				_columnSM.ExtendedProperties.Add("Length", "10");
				_columnSM.ExtendedProperties.Add("Decimals", "0");
				_columnSM.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnSM);
				
				_columnKREAL = new DataColumn("KREAL", typeof(string), "", MappingType.Element);
				_columnKREAL.AllowDBNull = true;
				_columnKREAL.Caption = "Kreal";
				_columnKREAL.MaxLength = 100;
				_columnKREAL.Unique = false;
				_columnKREAL.DefaultValue = Convert.DBNull;
				_columnKREAL.ExtendedProperties.Add("IsKey", "false");
				_columnKREAL.ExtendedProperties.Add("ReadOnly", "false");
				_columnKREAL.ExtendedProperties.Add("Description", "Kreal");
				_columnKREAL.ExtendedProperties.Add("Length", "100");
				_columnKREAL.ExtendedProperties.Add("Decimals", "0");
				_columnKREAL.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnKREAL);
				
				_columnGTPRE = new DataColumn("GTPRE", typeof(string), "", MappingType.Element);
				_columnGTPRE.AllowDBNull = true;
				_columnGTPRE.Caption = "Gtpre";
				_columnGTPRE.MaxLength = 2;
				_columnGTPRE.Unique = false;
				_columnGTPRE.DefaultValue = Convert.DBNull;
				_columnGTPRE.ExtendedProperties.Add("IsKey", "false");
				_columnGTPRE.ExtendedProperties.Add("ReadOnly", "false");
				_columnGTPRE.ExtendedProperties.Add("Description", "Gtpre");
				_columnGTPRE.ExtendedProperties.Add("Length", "2");
				_columnGTPRE.ExtendedProperties.Add("Decimals", "0");
				_columnGTPRE.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnGTPRE);
				
				_columnGTKEY = new DataColumn("GTKEY", typeof(string), "", MappingType.Element);
				_columnGTKEY.AllowDBNull = true;
				_columnGTKEY.Caption = "Gtkey";
				_columnGTKEY.MaxLength = 40;
				_columnGTKEY.Unique = false;
				_columnGTKEY.DefaultValue = Convert.DBNull;
				_columnGTKEY.ExtendedProperties.Add("IsKey", "false");
				_columnGTKEY.ExtendedProperties.Add("ReadOnly", "false");
				_columnGTKEY.ExtendedProperties.Add("Description", "Gtkey");
				_columnGTKEY.ExtendedProperties.Add("Length", "40");
				_columnGTKEY.ExtendedProperties.Add("Decimals", "0");
				_columnGTKEY.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnGTKEY);
				
				_columnPOS = new DataColumn("POS", typeof(int), "", MappingType.Element);
				_columnPOS.AllowDBNull = true;
				_columnPOS.Caption = "Pos";
				_columnPOS.Unique = false;
				_columnPOS.DefaultValue = Convert.DBNull;
				_columnPOS.ExtendedProperties.Add("IsKey", "false");
				_columnPOS.ExtendedProperties.Add("ReadOnly", "false");
				_columnPOS.ExtendedProperties.Add("Description", "Pos");
				_columnPOS.ExtendedProperties.Add("Decimals", "0");
				_columnPOS.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnPOS);
				
				_columnPROCESSPOINTKEY = new DataColumn("PROCESSPOINTKEY", typeof(string), "", MappingType.Element);
				_columnPROCESSPOINTKEY.AllowDBNull = true;
				_columnPROCESSPOINTKEY.Caption = "Processpointkey";
				_columnPROCESSPOINTKEY.MaxLength = 50;
				_columnPROCESSPOINTKEY.Unique = false;
				_columnPROCESSPOINTKEY.DefaultValue = Convert.DBNull;
				_columnPROCESSPOINTKEY.ExtendedProperties.Add("IsKey", "false");
				_columnPROCESSPOINTKEY.ExtendedProperties.Add("ReadOnly", "false");
				_columnPROCESSPOINTKEY.ExtendedProperties.Add("Description", "Processpointkey");
				_columnPROCESSPOINTKEY.ExtendedProperties.Add("Length", "50");
				_columnPROCESSPOINTKEY.ExtendedProperties.Add("Decimals", "0");
				_columnPROCESSPOINTKEY.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnPROCESSPOINTKEY);
				
				_columnGOODSASSEMBLEPOINTTYPEKEY = new DataColumn("GOODSASSEMBLEPOINTTYPEKEY", typeof(string), "", MappingType.Element);
				_columnGOODSASSEMBLEPOINTTYPEKEY.AllowDBNull = true;
				_columnGOODSASSEMBLEPOINTTYPEKEY.Caption = "Goodsassemblepointtypekey";
				_columnGOODSASSEMBLEPOINTTYPEKEY.MaxLength = 50;
				_columnGOODSASSEMBLEPOINTTYPEKEY.Unique = false;
				_columnGOODSASSEMBLEPOINTTYPEKEY.DefaultValue = Convert.DBNull;
				_columnGOODSASSEMBLEPOINTTYPEKEY.ExtendedProperties.Add("IsKey", "false");
				_columnGOODSASSEMBLEPOINTTYPEKEY.ExtendedProperties.Add("ReadOnly", "false");
				_columnGOODSASSEMBLEPOINTTYPEKEY.ExtendedProperties.Add("Description", "Goodsassemblepointtypekey");
				_columnGOODSASSEMBLEPOINTTYPEKEY.ExtendedProperties.Add("Length", "50");
				_columnGOODSASSEMBLEPOINTTYPEKEY.ExtendedProperties.Add("Decimals", "0");
				_columnGOODSASSEMBLEPOINTTYPEKEY.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnGOODSASSEMBLEPOINTTYPEKEY);
				
				_columnGOODSASSEMBLEPOINTKEY = new DataColumn("GOODSASSEMBLEPOINTKEY", typeof(string), "", MappingType.Element);
				_columnGOODSASSEMBLEPOINTKEY.AllowDBNull = true;
				_columnGOODSASSEMBLEPOINTKEY.Caption = "Goodsassemblepointkey";
				_columnGOODSASSEMBLEPOINTKEY.MaxLength = 50;
				_columnGOODSASSEMBLEPOINTKEY.Unique = false;
				_columnGOODSASSEMBLEPOINTKEY.DefaultValue = Convert.DBNull;
				_columnGOODSASSEMBLEPOINTKEY.ExtendedProperties.Add("IsKey", "false");
				_columnGOODSASSEMBLEPOINTKEY.ExtendedProperties.Add("ReadOnly", "false");
				_columnGOODSASSEMBLEPOINTKEY.ExtendedProperties.Add("Description", "Goodsassemblepointkey");
				_columnGOODSASSEMBLEPOINTKEY.ExtendedProperties.Add("Length", "50");
				_columnGOODSASSEMBLEPOINTKEY.ExtendedProperties.Add("Decimals", "0");
				_columnGOODSASSEMBLEPOINTKEY.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnGOODSASSEMBLEPOINTKEY);
				
				_columnGOODSMOVEMENTTYPEKEY = new DataColumn("GOODSMOVEMENTTYPEKEY", typeof(string), "", MappingType.Element);
				_columnGOODSMOVEMENTTYPEKEY.AllowDBNull = true;
				_columnGOODSMOVEMENTTYPEKEY.Caption = "Goodsmovementtypekey";
				_columnGOODSMOVEMENTTYPEKEY.MaxLength = 50;
				_columnGOODSMOVEMENTTYPEKEY.Unique = false;
				_columnGOODSMOVEMENTTYPEKEY.DefaultValue = Convert.DBNull;
				_columnGOODSMOVEMENTTYPEKEY.ExtendedProperties.Add("IsKey", "false");
				_columnGOODSMOVEMENTTYPEKEY.ExtendedProperties.Add("ReadOnly", "false");
				_columnGOODSMOVEMENTTYPEKEY.ExtendedProperties.Add("Description", "Goodsmovementtypekey");
				_columnGOODSMOVEMENTTYPEKEY.ExtendedProperties.Add("Length", "50");
				_columnGOODSMOVEMENTTYPEKEY.ExtendedProperties.Add("Decimals", "0");
				_columnGOODSMOVEMENTTYPEKEY.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnGOODSMOVEMENTTYPEKEY);
				
				_columnSKREAL = new DataColumn("SKREAL", typeof(string), "", MappingType.Element);
				_columnSKREAL.AllowDBNull = true;
				_columnSKREAL.Caption = "Skreal";
				_columnSKREAL.MaxLength = 100;
				_columnSKREAL.Unique = false;
				_columnSKREAL.DefaultValue = Convert.DBNull;
				_columnSKREAL.ExtendedProperties.Add("IsKey", "false");
				_columnSKREAL.ExtendedProperties.Add("ReadOnly", "false");
				_columnSKREAL.ExtendedProperties.Add("Description", "Skreal");
				_columnSKREAL.ExtendedProperties.Add("Length", "100");
				_columnSKREAL.ExtendedProperties.Add("Decimals", "0");
				_columnSKREAL.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnSKREAL);
				
				_columnSGTPRE = new DataColumn("SGTPRE", typeof(string), "", MappingType.Element);
				_columnSGTPRE.AllowDBNull = true;
				_columnSGTPRE.Caption = "Sgtpre";
				_columnSGTPRE.MaxLength = 2;
				_columnSGTPRE.Unique = false;
				_columnSGTPRE.DefaultValue = Convert.DBNull;
				_columnSGTPRE.ExtendedProperties.Add("IsKey", "false");
				_columnSGTPRE.ExtendedProperties.Add("ReadOnly", "false");
				_columnSGTPRE.ExtendedProperties.Add("Description", "Sgtpre");
				_columnSGTPRE.ExtendedProperties.Add("Length", "2");
				_columnSGTPRE.ExtendedProperties.Add("Decimals", "0");
				_columnSGTPRE.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnSGTPRE);
				
				_columnSGTKEY = new DataColumn("SGTKEY", typeof(string), "", MappingType.Element);
				_columnSGTKEY.AllowDBNull = true;
				_columnSGTKEY.Caption = "Sgtkey";
				_columnSGTKEY.MaxLength = 40;
				_columnSGTKEY.Unique = false;
				_columnSGTKEY.DefaultValue = Convert.DBNull;
				_columnSGTKEY.ExtendedProperties.Add("IsKey", "false");
				_columnSGTKEY.ExtendedProperties.Add("ReadOnly", "false");
				_columnSGTKEY.ExtendedProperties.Add("Description", "Sgtkey");
				_columnSGTKEY.ExtendedProperties.Add("Length", "40");
				_columnSGTKEY.ExtendedProperties.Add("Decimals", "0");
				_columnSGTKEY.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnSGTKEY);
				
				_columnSMULTIKEY = new DataColumn("SMULTIKEY", typeof(string), "", MappingType.Element);
				_columnSMULTIKEY.AllowDBNull = true;
				_columnSMULTIKEY.Caption = "Smultikey";
				_columnSMULTIKEY.MaxLength = 10;
				_columnSMULTIKEY.Unique = false;
				_columnSMULTIKEY.DefaultValue = Convert.DBNull;
				_columnSMULTIKEY.ExtendedProperties.Add("IsKey", "false");
				_columnSMULTIKEY.ExtendedProperties.Add("ReadOnly", "false");
				_columnSMULTIKEY.ExtendedProperties.Add("Description", "Smultikey");
				_columnSMULTIKEY.ExtendedProperties.Add("Length", "10");
				_columnSMULTIKEY.ExtendedProperties.Add("Decimals", "0");
				_columnSMULTIKEY.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnSMULTIKEY);
				
				_columnSFOREIGNKEY = new DataColumn("SFOREIGNKEY", typeof(string), "", MappingType.Element);
				_columnSFOREIGNKEY.AllowDBNull = true;
				_columnSFOREIGNKEY.Caption = "Sforeignkey";
				_columnSFOREIGNKEY.MaxLength = 100;
				_columnSFOREIGNKEY.Unique = false;
				_columnSFOREIGNKEY.DefaultValue = Convert.DBNull;
				_columnSFOREIGNKEY.ExtendedProperties.Add("IsKey", "false");
				_columnSFOREIGNKEY.ExtendedProperties.Add("ReadOnly", "false");
				_columnSFOREIGNKEY.ExtendedProperties.Add("Description", "Sforeignkey");
				_columnSFOREIGNKEY.ExtendedProperties.Add("Length", "100");
				_columnSFOREIGNKEY.ExtendedProperties.Add("Decimals", "0");
				_columnSFOREIGNKEY.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnSFOREIGNKEY);
				
				_columnSGOODSKEYGENERATION = new DataColumn("SGOODSKEYGENERATION", typeof(string), "", MappingType.Element);
				_columnSGOODSKEYGENERATION.AllowDBNull = true;
				_columnSGOODSKEYGENERATION.Caption = "Sgoodskeygeneration";
				_columnSGOODSKEYGENERATION.MaxLength = 10;
				_columnSGOODSKEYGENERATION.Unique = false;
				_columnSGOODSKEYGENERATION.DefaultValue = Convert.DBNull;
				_columnSGOODSKEYGENERATION.ExtendedProperties.Add("IsKey", "false");
				_columnSGOODSKEYGENERATION.ExtendedProperties.Add("ReadOnly", "false");
				_columnSGOODSKEYGENERATION.ExtendedProperties.Add("Description", "Sgoodskeygeneration");
				_columnSGOODSKEYGENERATION.ExtendedProperties.Add("Length", "10");
				_columnSGOODSKEYGENERATION.ExtendedProperties.Add("Decimals", "0");
				_columnSGOODSKEYGENERATION.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnSGOODSKEYGENERATION);
				
				_columnINQUANTITY = new DataColumn("INQUANTITY", typeof(string), "", MappingType.Element);
				_columnINQUANTITY.AllowDBNull = true;
				_columnINQUANTITY.Caption = "Inquantity";
				_columnINQUANTITY.MaxLength = 20;
				_columnINQUANTITY.Unique = false;
				_columnINQUANTITY.DefaultValue = Convert.DBNull;
				_columnINQUANTITY.ExtendedProperties.Add("IsKey", "false");
				_columnINQUANTITY.ExtendedProperties.Add("ReadOnly", "false");
				_columnINQUANTITY.ExtendedProperties.Add("Description", "Inquantity");
				_columnINQUANTITY.ExtendedProperties.Add("Length", "20");
				_columnINQUANTITY.ExtendedProperties.Add("Decimals", "0");
				_columnINQUANTITY.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnINQUANTITY);
				
				_columnINUM = new DataColumn("INUM", typeof(string), "", MappingType.Element);
				_columnINUM.AllowDBNull = true;
				_columnINUM.Caption = "Inum";
				_columnINUM.MaxLength = 3;
				_columnINUM.Unique = false;
				_columnINUM.DefaultValue = Convert.DBNull;
				_columnINUM.ExtendedProperties.Add("IsKey", "false");
				_columnINUM.ExtendedProperties.Add("ReadOnly", "false");
				_columnINUM.ExtendedProperties.Add("Description", "Inum");
				_columnINUM.ExtendedProperties.Add("Length", "3");
				_columnINUM.ExtendedProperties.Add("Decimals", "0");
				_columnINUM.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnINUM);
				
				_columnQUANTITY = new DataColumn("QUANTITY", typeof(string), "", MappingType.Element);
				_columnQUANTITY.AllowDBNull = true;
				_columnQUANTITY.Caption = "Quantity";
				_columnQUANTITY.MaxLength = 20;
				_columnQUANTITY.Unique = false;
				_columnQUANTITY.DefaultValue = Convert.DBNull;
				_columnQUANTITY.ExtendedProperties.Add("IsKey", "false");
				_columnQUANTITY.ExtendedProperties.Add("ReadOnly", "false");
				_columnQUANTITY.ExtendedProperties.Add("Description", "Quantity");
				_columnQUANTITY.ExtendedProperties.Add("Length", "20");
				_columnQUANTITY.ExtendedProperties.Add("Decimals", "0");
				_columnQUANTITY.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnQUANTITY);
				
				_columnUM = new DataColumn("UM", typeof(string), "", MappingType.Element);
				_columnUM.AllowDBNull = true;
				_columnUM.Caption = "Um";
				_columnUM.MaxLength = 3;
				_columnUM.Unique = false;
				_columnUM.DefaultValue = Convert.DBNull;
				_columnUM.ExtendedProperties.Add("IsKey", "false");
				_columnUM.ExtendedProperties.Add("ReadOnly", "false");
				_columnUM.ExtendedProperties.Add("Description", "Um");
				_columnUM.ExtendedProperties.Add("Length", "3");
				_columnUM.ExtendedProperties.Add("Decimals", "0");
				_columnUM.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnUM);
				
				_columnLDES = new DataColumn("LDES", typeof(string), "", MappingType.Element);
				_columnLDES.AllowDBNull = true;
				_columnLDES.Caption = "Ldes";
				_columnLDES.MaxLength = 250;
				_columnLDES.Unique = false;
				_columnLDES.DefaultValue = Convert.DBNull;
				_columnLDES.ExtendedProperties.Add("IsKey", "false");
				_columnLDES.ExtendedProperties.Add("ReadOnly", "false");
				_columnLDES.ExtendedProperties.Add("Description", "Ldes");
				_columnLDES.ExtendedProperties.Add("Length", "250");
				_columnLDES.ExtendedProperties.Add("Decimals", "0");
				_columnLDES.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnLDES);
				
				_columnSDES = new DataColumn("SDES", typeof(string), "", MappingType.Element);
				_columnSDES.AllowDBNull = true;
				_columnSDES.Caption = "Sdes";
				_columnSDES.MaxLength = 100;
				_columnSDES.Unique = false;
				_columnSDES.DefaultValue = Convert.DBNull;
				_columnSDES.ExtendedProperties.Add("IsKey", "false");
				_columnSDES.ExtendedProperties.Add("ReadOnly", "false");
				_columnSDES.ExtendedProperties.Add("Description", "Sdes");
				_columnSDES.ExtendedProperties.Add("Length", "100");
				_columnSDES.ExtendedProperties.Add("Decimals", "0");
				_columnSDES.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnSDES);
				
				_columnLPOS = new DataColumn("LPOS", typeof(int), "", MappingType.Element);
				_columnLPOS.AllowDBNull = true;
				_columnLPOS.Caption = "Lpos";
				_columnLPOS.Unique = false;
				_columnLPOS.DefaultValue = Convert.DBNull;
				_columnLPOS.ExtendedProperties.Add("IsKey", "false");
				_columnLPOS.ExtendedProperties.Add("ReadOnly", "false");
				_columnLPOS.ExtendedProperties.Add("Description", "Lpos");
				_columnLPOS.ExtendedProperties.Add("Decimals", "0");
				_columnLPOS.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnLPOS);
				
				_columnVALUECONTROLTYPEKEY = new DataColumn("VALUECONTROLTYPEKEY", typeof(string), "", MappingType.Element);
				_columnVALUECONTROLTYPEKEY.AllowDBNull = true;
				_columnVALUECONTROLTYPEKEY.Caption = "Valuecontroltypekey";
				_columnVALUECONTROLTYPEKEY.MaxLength = 50;
				_columnVALUECONTROLTYPEKEY.Unique = false;
				_columnVALUECONTROLTYPEKEY.DefaultValue = Convert.DBNull;
				_columnVALUECONTROLTYPEKEY.ExtendedProperties.Add("IsKey", "false");
				_columnVALUECONTROLTYPEKEY.ExtendedProperties.Add("ReadOnly", "false");
				_columnVALUECONTROLTYPEKEY.ExtendedProperties.Add("Description", "Valuecontroltypekey");
				_columnVALUECONTROLTYPEKEY.ExtendedProperties.Add("Length", "50");
				_columnVALUECONTROLTYPEKEY.ExtendedProperties.Add("Decimals", "0");
				_columnVALUECONTROLTYPEKEY.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnVALUECONTROLTYPEKEY);
				
				_columnEXPR1 = new DataColumn("EXPR1", typeof(string), "", MappingType.Element);
				_columnEXPR1.AllowDBNull = true;
				_columnEXPR1.Caption = "Expr 1";
				_columnEXPR1.MaxLength = 40;
				_columnEXPR1.Unique = false;
				_columnEXPR1.DefaultValue = Convert.DBNull;
				_columnEXPR1.ExtendedProperties.Add("IsKey", "false");
				_columnEXPR1.ExtendedProperties.Add("ReadOnly", "false");
				_columnEXPR1.ExtendedProperties.Add("Description", "Expr 1");
				_columnEXPR1.ExtendedProperties.Add("Length", "40");
				_columnEXPR1.ExtendedProperties.Add("Decimals", "0");
				_columnEXPR1.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnEXPR1);
				
				_columnSUBSTATUS = new DataColumn("SUBSTATUS", typeof(string), "", MappingType.Element);
				_columnSUBSTATUS.AllowDBNull = true;
				_columnSUBSTATUS.Caption = "Substatus";
				_columnSUBSTATUS.MaxLength = -1;
				_columnSUBSTATUS.Unique = false;
				_columnSUBSTATUS.DefaultValue = Convert.DBNull;
				_columnSUBSTATUS.ExtendedProperties.Add("IsKey", "false");
				_columnSUBSTATUS.ExtendedProperties.Add("ReadOnly", "false");
				_columnSUBSTATUS.ExtendedProperties.Add("Description", "Substatus");
				_columnSUBSTATUS.ExtendedProperties.Add("Length", "-1");
				_columnSUBSTATUS.ExtendedProperties.Add("Decimals", "0");
				_columnSUBSTATUS.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnSUBSTATUS);
				
				_columnSTATUS = new DataColumn("STATUS", typeof(string), "", MappingType.Element);
				_columnSTATUS.AllowDBNull = true;
				_columnSTATUS.Caption = "Status";
				_columnSTATUS.MaxLength = 50;
				_columnSTATUS.Unique = false;
				_columnSTATUS.DefaultValue = Convert.DBNull;
				_columnSTATUS.ExtendedProperties.Add("IsKey", "false");
				_columnSTATUS.ExtendedProperties.Add("ReadOnly", "false");
				_columnSTATUS.ExtendedProperties.Add("Description", "Status");
				_columnSTATUS.ExtendedProperties.Add("Length", "50");
				_columnSTATUS.ExtendedProperties.Add("Decimals", "0");
				_columnSTATUS.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnSTATUS);
				
				_columnFUSER = new DataColumn("FUSER", typeof(string), "", MappingType.Element);
				_columnFUSER.AllowDBNull = true;
				_columnFUSER.Caption = "Fuser";
				_columnFUSER.MaxLength = 10;
				_columnFUSER.Unique = false;
				_columnFUSER.DefaultValue = Convert.DBNull;
				_columnFUSER.ExtendedProperties.Add("IsKey", "false");
				_columnFUSER.ExtendedProperties.Add("ReadOnly", "false");
				_columnFUSER.ExtendedProperties.Add("Description", "Fuser");
				_columnFUSER.ExtendedProperties.Add("Length", "10");
				_columnFUSER.ExtendedProperties.Add("Decimals", "0");
				_columnFUSER.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnFUSER);
				
				_columnFDATE = new DataColumn("FDATE", typeof(DateTime), "", MappingType.Element);
				_columnFDATE.AllowDBNull = true;
				_columnFDATE.Caption = "Fdate";
				_columnFDATE.Unique = false;
				_columnFDATE.DefaultValue = Convert.DBNull;
				_columnFDATE.ExtendedProperties.Add("IsKey", "false");
				_columnFDATE.ExtendedProperties.Add("ReadOnly", "false");
				_columnFDATE.ExtendedProperties.Add("Description", "Fdate");
				_columnFDATE.ExtendedProperties.Add("Decimals", "0");
				_columnFDATE.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnFDATE);
				
				_columnLUSER = new DataColumn("LUSER", typeof(string), "", MappingType.Element);
				_columnLUSER.AllowDBNull = true;
				_columnLUSER.Caption = "Luser";
				_columnLUSER.MaxLength = 10;
				_columnLUSER.Unique = false;
				_columnLUSER.DefaultValue = Convert.DBNull;
				_columnLUSER.ExtendedProperties.Add("IsKey", "false");
				_columnLUSER.ExtendedProperties.Add("ReadOnly", "false");
				_columnLUSER.ExtendedProperties.Add("Description", "Luser");
				_columnLUSER.ExtendedProperties.Add("Length", "10");
				_columnLUSER.ExtendedProperties.Add("Decimals", "0");
				_columnLUSER.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnLUSER);
				
				_columnLDATE = new DataColumn("LDATE", typeof(DateTime), "", MappingType.Element);
				_columnLDATE.AllowDBNull = true;
				_columnLDATE.Caption = "Ldate";
				_columnLDATE.Unique = false;
				_columnLDATE.DefaultValue = Convert.DBNull;
				_columnLDATE.ExtendedProperties.Add("IsKey", "false");
				_columnLDATE.ExtendedProperties.Add("ReadOnly", "false");
				_columnLDATE.ExtendedProperties.Add("Description", "Ldate");
				_columnLDATE.ExtendedProperties.Add("Decimals", "0");
				_columnLDATE.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnLDATE);
				
				_columnUID = new DataColumn("UID", typeof(string), "", MappingType.Element);
				_columnUID.AllowDBNull = true;
				_columnUID.Caption = "Uid";
				_columnUID.MaxLength = 256;
				_columnUID.Unique = false;
				_columnUID.DefaultValue = Convert.DBNull;
				_columnUID.ExtendedProperties.Add("IsKey", "false");
				_columnUID.ExtendedProperties.Add("ReadOnly", "false");
				_columnUID.ExtendedProperties.Add("Description", "Uid");
				_columnUID.ExtendedProperties.Add("Length", "256");
				_columnUID.ExtendedProperties.Add("Decimals", "0");
				_columnUID.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnUID);
				
			}
			
			public GTARQueryCondRow NewGTARQueryCondRow()
			{
				GTARQueryCondRow rowGTARQueryCondRow = ((GTARQueryCondRow)(this.NewRow()));
				return rowGTARQueryCondRow;
			}
			
			protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
			{
				return new GTARQueryCondRow(builder);
			}
			
			protected override Type GetRowType()
			{
				return typeof(GTARQueryCondRow);
			}
			
			protected override void OnRowChanged(DataRowChangeEventArgs e)
			{
				base.OnRowChanged(e);
				if (this.GTARQueryCondRowChanged != null)
				{
					this.GTARQueryCondRowChanged(this, new GTARQueryCondRowChangeEventArgs(((GTARQueryCondRow)(e.Row)), e.Action));
				}
			}
			
			protected override void OnRowChanging(DataRowChangeEventArgs e)
			{
				base.OnRowChanging(e);
				if (this.GTARQueryCondRowChanging != null)
				{
					this.GTARQueryCondRowChanging(this, new GTARQueryCondRowChangeEventArgs(((GTARQueryCondRow)(e.Row)), e.Action));
				}
			}
			
			protected override void OnRowDeleted(DataRowChangeEventArgs e)
			{
				base.OnRowDeleted(e);
				if (this.GTARQueryCondRowDeleted != null)
				{
					this.GTARQueryCondRowDeleted(this, new GTARQueryCondRowChangeEventArgs(((GTARQueryCondRow)(e.Row)), e.Action));
				}
			}
			
			protected override void OnRowDeleting(DataRowChangeEventArgs e)
			{
				base.OnRowDeleting(e);
				if (this.GTARQueryCondRowDeleting != null)
				{
					this.GTARQueryCondRowDeleting(this, new GTARQueryCondRowChangeEventArgs(((GTARQueryCondRow)(e.Row)), e.Action));
				}
			}
			
			public void RemoveGTARQueryCondRow(GTARQueryCondRow row)
			{
				this.Rows.Remove(row);
			}
		}
		
		public class GTARQueryCondRow: DataRow
		{
			private GTARQueryCondDataTable _tableGTARQueryCond;
			
			internal GTARQueryCondRow(DataRowBuilder rb): base(rb)
			{
				_tableGTARQueryCond = ((GTARQueryCondDataTable)(this.Table));
			}
			
			/// <summary>
			/// Gets or sets the value of QUERYTYPE property
			/// </summary>
			public string QUERYTYPE
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.QUERYTYPEColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value QUERYTYPE because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.QUERYTYPEColumn] = value;
				}
			}
			
			public bool IsQUERYTYPENull()
			{
				return this.IsNull(_tableGTARQueryCond.QUERYTYPEColumn);
			}
			
			public void SetQUERYTYPENull()
			{
				this[_tableGTARQueryCond.QUERYTYPEColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of CONDTYPE property
			/// </summary>
			public string CONDTYPE
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.CONDTYPEColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value CONDTYPE because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.CONDTYPEColumn] = value;
				}
			}
			
			public bool IsCONDTYPENull()
			{
				return this.IsNull(_tableGTARQueryCond.CONDTYPEColumn);
			}
			
			public void SetCONDTYPENull()
			{
				this[_tableGTARQueryCond.CONDTYPEColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of REASON1 property
			/// </summary>
			public string REASON1
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.REASON1Column]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value REASON1 because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.REASON1Column] = value;
				}
			}
			
			public bool IsREASON1Null()
			{
				return this.IsNull(_tableGTARQueryCond.REASON1Column);
			}
			
			public void SetREASON1Null()
			{
				this[_tableGTARQueryCond.REASON1Column] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of FKREAL property
			/// </summary>
			public string FKREAL
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.FKREALColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value FKREAL because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.FKREALColumn] = value;
				}
			}
			
			public bool IsFKREALNull()
			{
				return this.IsNull(_tableGTARQueryCond.FKREALColumn);
			}
			
			public void SetFKREALNull()
			{
				this[_tableGTARQueryCond.FKREALColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of SM property
			/// </summary>
			public string SM
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.SMColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value SM because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.SMColumn] = value;
				}
			}
			
			public bool IsSMNull()
			{
				return this.IsNull(_tableGTARQueryCond.SMColumn);
			}
			
			public void SetSMNull()
			{
				this[_tableGTARQueryCond.SMColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of KREAL property
			/// </summary>
			public string KREAL
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.KREALColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value KREAL because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.KREALColumn] = value;
				}
			}
			
			public bool IsKREALNull()
			{
				return this.IsNull(_tableGTARQueryCond.KREALColumn);
			}
			
			public void SetKREALNull()
			{
				this[_tableGTARQueryCond.KREALColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of GTPRE property
			/// </summary>
			public string GTPRE
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.GTPREColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value GTPRE because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.GTPREColumn] = value;
				}
			}
			
			public bool IsGTPRENull()
			{
				return this.IsNull(_tableGTARQueryCond.GTPREColumn);
			}
			
			public void SetGTPRENull()
			{
				this[_tableGTARQueryCond.GTPREColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of GTKEY property
			/// </summary>
			public string GTKEY
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.GTKEYColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value GTKEY because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.GTKEYColumn] = value;
				}
			}
			
			public bool IsGTKEYNull()
			{
				return this.IsNull(_tableGTARQueryCond.GTKEYColumn);
			}
			
			public void SetGTKEYNull()
			{
				this[_tableGTARQueryCond.GTKEYColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of POS property
			/// </summary>
			public int POS
			{
				get
				{
					try
					{
						return ((int)(this[_tableGTARQueryCond.POSColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value POS because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.POSColumn] = value;
				}
			}
			
			public bool IsPOSNull()
			{
				return this.IsNull(_tableGTARQueryCond.POSColumn);
			}
			
			public void SetPOSNull()
			{
				this[_tableGTARQueryCond.POSColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of PROCESSPOINTKEY property
			/// </summary>
			public string PROCESSPOINTKEY
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.PROCESSPOINTKEYColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value PROCESSPOINTKEY because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.PROCESSPOINTKEYColumn] = value;
				}
			}
			
			public bool IsPROCESSPOINTKEYNull()
			{
				return this.IsNull(_tableGTARQueryCond.PROCESSPOINTKEYColumn);
			}
			
			public void SetPROCESSPOINTKEYNull()
			{
				this[_tableGTARQueryCond.PROCESSPOINTKEYColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of GOODSASSEMBLEPOINTTYPEKEY property
			/// </summary>
			public string GOODSASSEMBLEPOINTTYPEKEY
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.GOODSASSEMBLEPOINTTYPEKEYColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value GOODSASSEMBLEPOINTTYPEKEY because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.GOODSASSEMBLEPOINTTYPEKEYColumn] = value;
				}
			}
			
			public bool IsGOODSASSEMBLEPOINTTYPEKEYNull()
			{
				return this.IsNull(_tableGTARQueryCond.GOODSASSEMBLEPOINTTYPEKEYColumn);
			}
			
			public void SetGOODSASSEMBLEPOINTTYPEKEYNull()
			{
				this[_tableGTARQueryCond.GOODSASSEMBLEPOINTTYPEKEYColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of GOODSASSEMBLEPOINTKEY property
			/// </summary>
			public string GOODSASSEMBLEPOINTKEY
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.GOODSASSEMBLEPOINTKEYColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value GOODSASSEMBLEPOINTKEY because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.GOODSASSEMBLEPOINTKEYColumn] = value;
				}
			}
			
			public bool IsGOODSASSEMBLEPOINTKEYNull()
			{
				return this.IsNull(_tableGTARQueryCond.GOODSASSEMBLEPOINTKEYColumn);
			}
			
			public void SetGOODSASSEMBLEPOINTKEYNull()
			{
				this[_tableGTARQueryCond.GOODSASSEMBLEPOINTKEYColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of GOODSMOVEMENTTYPEKEY property
			/// </summary>
			public string GOODSMOVEMENTTYPEKEY
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.GOODSMOVEMENTTYPEKEYColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value GOODSMOVEMENTTYPEKEY because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.GOODSMOVEMENTTYPEKEYColumn] = value;
				}
			}
			
			public bool IsGOODSMOVEMENTTYPEKEYNull()
			{
				return this.IsNull(_tableGTARQueryCond.GOODSMOVEMENTTYPEKEYColumn);
			}
			
			public void SetGOODSMOVEMENTTYPEKEYNull()
			{
				this[_tableGTARQueryCond.GOODSMOVEMENTTYPEKEYColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of SKREAL property
			/// </summary>
			public string SKREAL
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.SKREALColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value SKREAL because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.SKREALColumn] = value;
				}
			}
			
			public bool IsSKREALNull()
			{
				return this.IsNull(_tableGTARQueryCond.SKREALColumn);
			}
			
			public void SetSKREALNull()
			{
				this[_tableGTARQueryCond.SKREALColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of SGTPRE property
			/// </summary>
			public string SGTPRE
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.SGTPREColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value SGTPRE because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.SGTPREColumn] = value;
				}
			}
			
			public bool IsSGTPRENull()
			{
				return this.IsNull(_tableGTARQueryCond.SGTPREColumn);
			}
			
			public void SetSGTPRENull()
			{
				this[_tableGTARQueryCond.SGTPREColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of SGTKEY property
			/// </summary>
			public string SGTKEY
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.SGTKEYColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value SGTKEY because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.SGTKEYColumn] = value;
				}
			}
			
			public bool IsSGTKEYNull()
			{
				return this.IsNull(_tableGTARQueryCond.SGTKEYColumn);
			}
			
			public void SetSGTKEYNull()
			{
				this[_tableGTARQueryCond.SGTKEYColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of SMULTIKEY property
			/// </summary>
			public string SMULTIKEY
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.SMULTIKEYColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value SMULTIKEY because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.SMULTIKEYColumn] = value;
				}
			}
			
			public bool IsSMULTIKEYNull()
			{
				return this.IsNull(_tableGTARQueryCond.SMULTIKEYColumn);
			}
			
			public void SetSMULTIKEYNull()
			{
				this[_tableGTARQueryCond.SMULTIKEYColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of SFOREIGNKEY property
			/// </summary>
			public string SFOREIGNKEY
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.SFOREIGNKEYColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value SFOREIGNKEY because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.SFOREIGNKEYColumn] = value;
				}
			}
			
			public bool IsSFOREIGNKEYNull()
			{
				return this.IsNull(_tableGTARQueryCond.SFOREIGNKEYColumn);
			}
			
			public void SetSFOREIGNKEYNull()
			{
				this[_tableGTARQueryCond.SFOREIGNKEYColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of SGOODSKEYGENERATION property
			/// </summary>
			public string SGOODSKEYGENERATION
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.SGOODSKEYGENERATIONColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value SGOODSKEYGENERATION because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.SGOODSKEYGENERATIONColumn] = value;
				}
			}
			
			public bool IsSGOODSKEYGENERATIONNull()
			{
				return this.IsNull(_tableGTARQueryCond.SGOODSKEYGENERATIONColumn);
			}
			
			public void SetSGOODSKEYGENERATIONNull()
			{
				this[_tableGTARQueryCond.SGOODSKEYGENERATIONColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of INQUANTITY property
			/// </summary>
			public string INQUANTITY
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.INQUANTITYColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value INQUANTITY because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.INQUANTITYColumn] = value;
				}
			}
			
			public bool IsINQUANTITYNull()
			{
				return this.IsNull(_tableGTARQueryCond.INQUANTITYColumn);
			}
			
			public void SetINQUANTITYNull()
			{
				this[_tableGTARQueryCond.INQUANTITYColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of INUM property
			/// </summary>
			public string INUM
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.INUMColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value INUM because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.INUMColumn] = value;
				}
			}
			
			public bool IsINUMNull()
			{
				return this.IsNull(_tableGTARQueryCond.INUMColumn);
			}
			
			public void SetINUMNull()
			{
				this[_tableGTARQueryCond.INUMColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of QUANTITY property
			/// </summary>
			public string QUANTITY
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.QUANTITYColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value QUANTITY because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.QUANTITYColumn] = value;
				}
			}
			
			public bool IsQUANTITYNull()
			{
				return this.IsNull(_tableGTARQueryCond.QUANTITYColumn);
			}
			
			public void SetQUANTITYNull()
			{
				this[_tableGTARQueryCond.QUANTITYColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of UM property
			/// </summary>
			public string UM
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.UMColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value UM because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.UMColumn] = value;
				}
			}
			
			public bool IsUMNull()
			{
				return this.IsNull(_tableGTARQueryCond.UMColumn);
			}
			
			public void SetUMNull()
			{
				this[_tableGTARQueryCond.UMColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of LDES property
			/// </summary>
			public string LDES
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.LDESColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value LDES because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.LDESColumn] = value;
				}
			}
			
			public bool IsLDESNull()
			{
				return this.IsNull(_tableGTARQueryCond.LDESColumn);
			}
			
			public void SetLDESNull()
			{
				this[_tableGTARQueryCond.LDESColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of SDES property
			/// </summary>
			public string SDES
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.SDESColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value SDES because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.SDESColumn] = value;
				}
			}
			
			public bool IsSDESNull()
			{
				return this.IsNull(_tableGTARQueryCond.SDESColumn);
			}
			
			public void SetSDESNull()
			{
				this[_tableGTARQueryCond.SDESColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of LPOS property
			/// </summary>
			public int LPOS
			{
				get
				{
					try
					{
						return ((int)(this[_tableGTARQueryCond.LPOSColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value LPOS because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.LPOSColumn] = value;
				}
			}
			
			public bool IsLPOSNull()
			{
				return this.IsNull(_tableGTARQueryCond.LPOSColumn);
			}
			
			public void SetLPOSNull()
			{
				this[_tableGTARQueryCond.LPOSColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of VALUECONTROLTYPEKEY property
			/// </summary>
			public string VALUECONTROLTYPEKEY
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.VALUECONTROLTYPEKEYColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value VALUECONTROLTYPEKEY because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.VALUECONTROLTYPEKEYColumn] = value;
				}
			}
			
			public bool IsVALUECONTROLTYPEKEYNull()
			{
				return this.IsNull(_tableGTARQueryCond.VALUECONTROLTYPEKEYColumn);
			}
			
			public void SetVALUECONTROLTYPEKEYNull()
			{
				this[_tableGTARQueryCond.VALUECONTROLTYPEKEYColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of EXPR1 property
			/// </summary>
			public string EXPR1
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.EXPR1Column]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value EXPR1 because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.EXPR1Column] = value;
				}
			}
			
			public bool IsEXPR1Null()
			{
				return this.IsNull(_tableGTARQueryCond.EXPR1Column);
			}
			
			public void SetEXPR1Null()
			{
				this[_tableGTARQueryCond.EXPR1Column] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of SUBSTATUS property
			/// </summary>
			public string SUBSTATUS
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.SUBSTATUSColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value SUBSTATUS because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.SUBSTATUSColumn] = value;
				}
			}
			
			public bool IsSUBSTATUSNull()
			{
				return this.IsNull(_tableGTARQueryCond.SUBSTATUSColumn);
			}
			
			public void SetSUBSTATUSNull()
			{
				this[_tableGTARQueryCond.SUBSTATUSColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of STATUS property
			/// </summary>
			public string STATUS
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.STATUSColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value STATUS because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.STATUSColumn] = value;
				}
			}
			
			public bool IsSTATUSNull()
			{
				return this.IsNull(_tableGTARQueryCond.STATUSColumn);
			}
			
			public void SetSTATUSNull()
			{
				this[_tableGTARQueryCond.STATUSColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of FUSER property
			/// </summary>
			public string FUSER
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.FUSERColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value FUSER because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.FUSERColumn] = value;
				}
			}
			
			public bool IsFUSERNull()
			{
				return this.IsNull(_tableGTARQueryCond.FUSERColumn);
			}
			
			public void SetFUSERNull()
			{
				this[_tableGTARQueryCond.FUSERColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of FDATE property
			/// </summary>
			public DateTime FDATE
			{
				get
				{
					try
					{
						return ((DateTime)(this[_tableGTARQueryCond.FDATEColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value FDATE because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.FDATEColumn] = value;
				}
			}
			
			public bool IsFDATENull()
			{
				return this.IsNull(_tableGTARQueryCond.FDATEColumn);
			}
			
			public void SetFDATENull()
			{
				this[_tableGTARQueryCond.FDATEColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of LUSER property
			/// </summary>
			public string LUSER
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.LUSERColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value LUSER because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.LUSERColumn] = value;
				}
			}
			
			public bool IsLUSERNull()
			{
				return this.IsNull(_tableGTARQueryCond.LUSERColumn);
			}
			
			public void SetLUSERNull()
			{
				this[_tableGTARQueryCond.LUSERColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of LDATE property
			/// </summary>
			public DateTime LDATE
			{
				get
				{
					try
					{
						return ((DateTime)(this[_tableGTARQueryCond.LDATEColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value LDATE because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.LDATEColumn] = value;
				}
			}
			
			public bool IsLDATENull()
			{
				return this.IsNull(_tableGTARQueryCond.LDATEColumn);
			}
			
			public void SetLDATENull()
			{
				this[_tableGTARQueryCond.LDATEColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of UID property
			/// </summary>
			public string UID
			{
				get
				{
					try
					{
						return ((string)(this[_tableGTARQueryCond.UIDColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value UID because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableGTARQueryCond.UIDColumn] = value;
				}
			}
			
			public bool IsUIDNull()
			{
				return this.IsNull(_tableGTARQueryCond.UIDColumn);
			}
			
			public void SetUIDNull()
			{
				this[_tableGTARQueryCond.UIDColumn] = Convert.DBNull;
			}
			
		}
		
		public class GTARQueryCondRowChangeEventArgs: EventArgs
		{
			private GTARQueryCondRow _eventRow;
			private System.Data.DataRowAction _eventAction;
			
			public GTARQueryCondRowChangeEventArgs(GTARQueryCondRow row, DataRowAction action)
			{
				_eventRow = row;
				_eventAction = action;
			}
			
			public GTARQueryCondRow Row
			{
				get
				{
					return _eventRow;
				}
			}
			
			public DataRowAction Action
			{
				get
				{
					return _eventAction;
				}
			}
		}
	}
	#endregion
    }
